AI Frontier
The state of the art in 2025–2026 — cross-cutting developments that span every module, reshaping how AI is built, deployed, and governed in financial services.
This module covers developments that don't fit neatly into one topic — they cut across foundation models, agents, security, and governance simultaneously. It is updated as the field moves, so check back regularly. Each section notes its most recent update.
Multimodal AI — The New Default
Updated Oct 2026Multimodality is no longer a feature — it is the baseline. Every frontier model now handles text plus images, and several handle audio, video, and code execution in the same model.
Read earnings slides, scanned contracts, portfolio charts, handwritten notes
Voice-enabled advisor assistant; live client call analysis; instant transcription + summary
Analyse recorded board meetings, analyse trading floor footage for compliance
Upload CSV of transactions; model writes, runs, and explains the analysis — no manual coding
Generate audio risk briefings, multilingual client communications
Process PDFs/Excel natively — layout, tables, footnotes preserved; no OCR pipeline
The Practical Shift
In 2023, processing a scanned regulatory document required: OCR → text cleaning → chunking → embedding → RAG. In 2026, you pass the PDF page as an image and ask your question. Finance teams that still maintain complex text extraction pipelines should question whether they are over-engineering.
On-Device AI — The Privacy-First Architecture
Updated Oct 2026Small but capable models now run entirely on the device — no data leaves the endpoint. This is not a compromise; for many financial use cases, it is the preferred architecture.
Models That Run On-Device
Processes personal data on-chip. Cloud model only for complex queries via Private Cloud Compute.
Near-frontier quality at 14B params. Runs in Windows AI Studio, Ollama, LM Studio.
Open weights from Google. Competitive with early GPT-4 on many benchmarks.
Officially supports on-device deployment. Multimodal (11B handles images).
Why Finance Should Care
Material Non-Public Information never leaves the building. Critical for investment banking, M&A desks, research teams with information barriers.
RBI data localisation, EU GDPR, DPDP Act 2023 — on-device means zero cross-border data transfer risk.
No prompt logging at a third-party provider. Simpler evidence for SR 11-7 model validation.
Works in secure rooms, on trading floors with restricted internet, or in low-connectivity markets.
High-volume, low-complexity tasks (classification, PII detection, document tagging) can be zero marginal cost with on-device models.
AI in Production — What Mature Teams Do Differently
Updated Oct 2026The gap between a demo and a production system in 2026 is wider than ever. Here is what separates teams shipping real value from teams stuck in POC loops.
Evals as the Core Discipline
The teams shipping fastest have invested heavily in evaluation pipelines — not just unit tests, but automated measurement of output quality on domain-specific benchmarks. 'Does it work?' has been replaced by 'What is the task success rate on our golden set?'
Tools: LangSmith, Braintrust, promptfoo, DeepEval, custom pytest suites
Model Routing & Cascading
Production systems don't use one model for everything. Route simple, high-volume tasks to fast/cheap models (Haiku, o4-mini, Gemini Flash), escalate complex tasks to frontier models. Reduces cost 60–80% with minimal quality loss.
Tools: LiteLLM, custom routers, OpenRouter, Azure AI Model Catalog
Observability as a Requirement
Every prompt, every response, every tool call, every latency and cost number is logged — with PII redacted. You can't improve what you can't measure. Finance adds compliance logging on top: audit trails for every AI-assisted decision.
Tools: LangSmith, Weights & Biases, Langfuse, Helicone, custom SIEM integration
Prompt Version Control
Prompts are code. They live in Git, go through code review, are tested before deployment, and have rollback procedures. A prompt change is treated the same as a model weight change under SR 11-7 model risk management.
Tools: Langfuse, PromptLayer, custom Git workflows, CI/CD gates
Human-in-the-Loop by Design
Mature systems don't try to automate everything end-to-end on day one. They identify exactly which steps require human review (regulatory filings, client communications, credit decisions) and build that into the workflow from the start.
Tools: LangGraph (interrupt nodes), custom approval UIs, email/Slack approval flows
Cost Accountability
AI costs are tracked per team, per use case, per model. Chargeback mechanisms ensure teams that build expensive agent loops feel the cost. Budget alerts, token quotas, and monthly cost forecasts are standard.
Tools: LLM Gateway with cost attribution, Azure Cost Management, custom dashboards
The 2026 Production Stack (Finance)
Open vs Closed Models — The 2026 Decision Framework
Updated Oct 2026The gap between open and closed models has narrowed dramatically. DeepSeek-R1 and Llama 4 compete directly with frontier closed models on many benchmarks. The decision is now strategic, not purely technical.
| Dimension | Closed (GPT-4o, Claude, Gemini) | Open (Llama 4, DeepSeek, Mistral) |
|---|---|---|
| Data privacy | Data sent to vendor; strong contractual protections; no training on customer data (Azure OpenAI, Claude API) | Runs in your VPC or on-premise; data never leaves; strongest for MNPI and regulated data |
| Quality (general) | Still ahead on complex reasoning, nuanced understanding, edge cases | Rapidly closing gap; Llama 4 Maverick near GPT-4o on most benchmarks |
| Cost | API pricing per token; high volume = expensive | Self-hosted: pay for compute, not tokens; cost-efficient at scale |
| Customisation | Fine-tuning available but limited; model weights not accessible | Full weights: fine-tune, distil, quantize, merge with domain data |
| Latency | Network round-trip; provider SLA | Self-hosted: control your own infrastructure; can be faster for high throughput |
| Vendor risk | Dependent on vendor pricing, availability, model updates | No vendor lock-in; community supported; forkable |
| Compliance evidence | Vendor SOC 2/ISO 27001; DPAs available; limited interpretability | Full control of model lifecycle; easier SR 11-7 documentation |
| Indian market fit | Azure OpenAI in India Central; data residency options | Self-host in Indian data centres; meets RBI data localisation requirements |
The Emerging Pattern: Tiered Architecture
Most mature financial AI programs use a tiered approach: open models on-premise for highly sensitive data (MNPI, client PII) and high-volume low-complexity tasks; closed frontier models via private endpoints for complex reasoning on non-sensitive data; small on-device models for the most sensitive edge-case workflows. Not either/or — a portfolio of models matched to task and data sensitivity.
The Agentic Internet — AI Acting in the World
Updated Oct 2026We are entering an era where AI agents don't just answer questions — they take actions in the world: browsing, filling forms, making API calls, orchestrating other agents, and executing multi-hour autonomous workflows.
What's Already Happening
- Agents booking meetings, ordering supplies, filing expense reports — fully autonomously
- Software agents writing code, running tests, submitting pull requests (GitHub Copilot Workspace, Devin 2.0)
- Research agents: given a question, spend 30 minutes searching, reading, synthesizing — deliver a cited report
- Sales agents: qualify leads, personalise outreach, book demos without human involvement
- Compliance agents: monitor transactions in real time, flag anomalies, draft SAR reports for human review
Finance-Specific Agent Workflows (2026)
- Trade break investigation: agent reads the ticket, queries settlement systems, identifies the cause, drafts a fix — human approves
- Regulatory filing: agent reads the circular, maps obligations, updates the compliance calendar, flags gaps to the team
- Client onboarding: agent orchestrates KYC checks across multiple databases, drafts the account opening recommendation
- Research synthesis: given an investment thesis, agent reads 50 earnings transcripts, builds a comparison table, flags outliers
- Fund reconciliation: nightly agent reconciles NAV across custodians, flags discrepancies for human review by 6am
The Governance Challenge
As agents gain autonomy, accountability becomes critical. Who is responsible when an agent makes a wrong trade or sends a wrong communication? Current regulatory frameworks (SR 11-7, EU AI Act, FCA guidance) are being extended to cover agentic systems — but the frameworks lag the technology. Banks are establishing Agent Governance Committees and requiring human-in-the-loop for all consequential financial actions.
AI & the Finance Workforce — Honest Assessment
Updated Oct 2026The question everyone is asking but few answer clearly. Here is the honest picture as of 2026.
Roles being automated (tasks, not jobs)
- First-pass document review (contracts, regulatory filings)
- Data extraction from reports (manual copy-paste)
- Routine client query answering (FAQ, account status)
- Basic financial modelling templates
- Meeting summaries and action item capture
- First-draft report writing
Roles being augmented (more productive)
- Research analysts (AI handles data gathering, human handles judgment)
- Compliance officers (AI monitors, human adjudicates)
- Relationship managers (AI drafts, human personalises and builds trust)
- Risk managers (AI identifies, human decides appetite)
- Software developers (AI writes code, engineer reviews and architects)
- Regulators (AI spots patterns, regulator sets policy)
New roles emerging
- AI/ML Engineers in finance (high demand, significant pay premium)
- Prompt engineers / AI product managers
- AI compliance officers (AI governance specialist)
- AI red teamers and security engineers
- AI model validators (SR 11-7 for LLMs)
- Data curators for fine-tuning and RAG pipelines
The Skill That Protects Your Career
The professionals thriving in 2026 are not those who resist AI, nor those who blindly delegate to it. They are the ones who understand what AI can and cannot do, direct it precisely, verify its outputs critically, and take responsibility for the outcome. Domain expertise + AI fluency = the 10× professional.
What's Next — Signals to Watch
Updated Oct 2026These are the developments most likely to reshape financial AI in the next 12–18 months. Not predictions — signals based on current research and product roadmaps.
Physical AI (Robotics + LLM)
12–24 monthsLLMs controlling physical systems — not just software. JPMorgan and others experimenting with AI for data centre operations. Watch for AI in trading floor operations, vault management, physical compliance checks.
AI Scientists & Autonomous R&D
Now → 2027Models like Google AlphaFold 3 and DeepMind AlphaProof solve research problems autonomously. Finance application: AI discovering new risk factors, generating novel hedging strategies, autonomously back-testing.
Regulatory AI Requirements
2026–2027EU AI Act high-risk obligations kick in fully. RBI and SEBI expected to issue binding AI guidelines. FCA expanding AI in finance guidance. Expect mandatory red-teaming, bias reporting, and human oversight documentation for all client-facing AI.
AI-Native Financial Products
NowFinancial products designed around AI from the ground up — AI-managed ETFs, AI-driven insurance underwriting, AI credit products. The AI is not a tool used by humans; it is the decision-maker with human oversight.
Standardised AI Auditing
2026–2028ISO 42001 certification starting to be required by large enterprises from their AI vendors. Big 4 firms building AI audit practices. Expect AI audit to become as standard as financial audit within 5 years.
Multimodal Foundation Models for Finance
2026–2027Finance-specific models trained on market data, regulatory text, earnings transcripts, and financial tables simultaneously. Bloomberg's second-generation models, JPMorgan's internal models, and open alternatives.
Harness Engineering — Scaffolding Around AI Models
Updated Oct 2026A harness is the systematic scaffolding you build around a model — not the model itself. The model is the engine; the harness is the chassis, the dashboard, the safety systems, and the test rig. Most production AI failures happen in the harness, not the model.
DSPy — Programming LMs Instead of Prompting Them
DSPy (Declarative Self-improving Python) from Stanford treats prompts as learnable parameters, not hardcoded strings. You write a program that describes what you want — DSPy automatically finds the best prompts, few-shot examples, and chain-of-thought strategies using gradient-free optimisation (like a compiler for LM programs).
Traditional approach:
# Hand-craft every prompt variation # Manually test & tweak # Breaks when model updates prompt = """You are a financial analyst. Analyse this report and extract: 1. Revenue growth... 2. Margin trends..."""
DSPy approach:
import dspy
class FinancialAnalyser(dspy.Signature):
"""Extract key metrics from a report."""
report = dspy.InputField()
metrics = dspy.OutputField(
desc="revenue, margins, risks"
)
analyser = dspy.Predict(FinancialAnalyser)
# DSPy compiles optimal prompt automaticallyBootstrapFewShot, MIPRO, BayesianSignatureOptimizer — automatically find best prompts and examples from your training data
Predict, ChainOfThought, ReAct, Retrieve — composable building blocks that replace hand-crafted prompt chains
Compile an optimal credit analysis prompt from 50 labelled examples — automatically, without manual prompt engineering
Evaluation Harnesses — Systematic Model Testing
An eval harness is a framework for running structured, repeatable tests against a model or pipeline. The difference between "does it work?" and "how well does it work on category X, across 500 cases, at temperature 0.7?" — that requires a harness.
| Harness | What It Does | Best For |
|---|---|---|
| EleutherAI LM Eval Harness | Standardised benchmarks: MMLU, HellaSwag, TruthfulQA, BIG-bench. Run any model against any benchmark. | Comparing open models; validating fine-tuned models against base model |
| promptfoo | YAML-driven test cases for your specific prompts and pipelines. CI/CD integration with pass/fail gates. | Production prompt testing; security evals mapped to OWASP/ATLAS |
| Braintrust | Dataset management, eval runs, scoring, human annotation, regression tracking — all in one platform. | Teams that need full eval lifecycle management |
| RAGAS | Evaluation framework specifically for RAG pipelines: faithfulness, answer relevancy, context recall. | Validating RAG quality before and after changes |
| DeepEval | Pytest-style evals with 14+ built-in metrics (G-Eval, hallucination, toxicity, bias, summarisation). | Python-native teams wanting eval as code in CI |
# DeepEval: eval as code in CI/CD — finance example
from deepeval import evaluate
from deepeval.metrics import (
AnswerRelevancyMetric,
HallucinationMetric,
FaithfulnessMetric,
)
from deepeval.test_case import LLMTestCase
test_case = LLMTestCase(
input="What is the repo rate set by RBI in Q3 2025?",
actual_output=model_response,
expected_output="6.50%",
retrieval_context=retrieved_chunks,
)
evaluate(
test_cases=[test_case],
metrics=[
AnswerRelevancyMetric(threshold=0.8),
HallucinationMetric(threshold=0.1), # max 10% hallucination
FaithfulnessMetric(threshold=0.9), # grounded in sources
],
)Prompt Management — Treating Prompts as Code
A prompt change is a model behaviour change. In regulated environments, it needs the same governance as a code change: version control, review, testing, staged rollout, rollback.
Every prompt in Git. Diffs are reviewable. History is auditable. SR 11-7 requires documentation of what changed and when.
Canary deploy to 5% of traffic → measure quality metrics → full rollout. Same discipline as software releases.
Run prompt A and B in parallel, measure quality scores, latency, cost, user satisfaction. Pick the winner on data, not intuition.
When a model vendor silently updates their model and your prompt's behaviour changes, you need to roll back your prompt instantly.
Tools:
Loop Engineering — Making Models Think, Refine & Improve
Updated Oct 2026Loop engineering is the design of iterative AI processes — structuring how a model reasons, critiques, refines, and improves over multiple steps. It is the engineering discipline behind reasoning models, self-improving pipelines, and high-quality agent outputs.
Test-Time Compute Scaling
The insight behind o1, o3, and DeepSeek-R1: spending more compute at inference time (thinking longer) yields better answers — sometimes dramatically so. This shifts the question from "how big is the model?" to "how long should it think?"
The model generates a long chain of thought before answering — reasoning step by step through the problem. Internally done in o1/o3/R1. More tokens spent thinking = better final answer.
Multi-step credit risk: analyse collateral → assess macro conditions → evaluate management quality → produce rating
Generate N answers independently, use a verifier/judge to pick the best one. Simple but powerful — more compute buys more quality.
Generate 5 regulatory interpretations, use a compliance LLM-as-judge to select the most accurate and conservative one
A separate model scores each reasoning step (not just the final answer). The main model searches for paths where each step is rewarded — like a chess engine evaluating board positions.
Validate each step of a derivatives pricing calculation, not just the final price
Self-Refinement Loops
A class of techniques where the model critiques and improves its own output — without human feedback, using the model's own knowledge as the critic.
- 1. Generate initial answer
- 2. Critique: what is wrong or incomplete?
- 3. Refine: produce improved answer based on critique
- 4. Repeat until quality threshold met or N iterations
Draft a client investment proposal → critique for regulatory compliance gaps → refine → check again
- 1. Model generates a response
- 2. Model critiques it against a set of principles ('the constitution')
- 3. Model revises based on its own critique
- 4. Used in Claude's training — but also usable at inference time
Define a 'financial advice constitution' — principles like 'never recommend leverage above X' — and have the model self-check against it
- 1. Agent attempts a task
- 2. Evaluator scores the outcome
- 3. Agent reflects on the failure in natural language
- 4. Reflection stored as memory for next attempt
- 5. Repeat — agent improves across episodes
Compliance checking agent learns from each missed obligation, stores reflections, improves on subsequent documents
- 1. Two or more agents produce independent answers
- 2. Agents see each other's answers and critique them
- 3. Multiple rounds of debate
- 4. Final answer is the consensus or judged winner
Bull agent vs Bear agent debate on a stock — forces both sides of an investment thesis, reduces anchoring bias
Advanced Reasoning Structures
Instead of one linear chain of thought, explore multiple reasoning branches simultaneously. Evaluate each branch, prune dead ends, continue promising ones — like a search tree.
Finance when: Complex problems with multiple valid approaches: M&A deal structuring, portfolio optimisation under constraints
Extends ToT to arbitrary graph structures — reasoning branches can merge, loop, and recombine. More flexible than trees for problems with interdependencies.
Finance when: Regulatory mapping (rules reference other rules), multi-factor risk analysis where factors interact
Generate an outline (skeleton) first, then fill in each section in parallel. Reduces latency while preserving structure.
Finance when: Generating long structured reports (investment memos, regulatory submissions) where sections are largely independent
Training-Time Loops — How Models Are Aligned
Understanding training loops matters for two reasons: it explains why models behave as they do, and it determines what fine-tuning approaches are appropriate for financial use cases.
Humans rank model outputs → reward model trained → main model fine-tuned via PPO to maximise reward. Powers ChatGPT and Claude's initial alignment.
Can be adapted for financial preference data: ranking credit analysis outputs by accuracy
Simpler alternative to RLHF — no separate reward model. Directly trains on human preference pairs (preferred vs rejected response). Less compute, easier to implement.
Fine-tune a compliance model on labelled pairs of compliant vs non-compliant advisory language
Used in DeepSeek-R1. Groups of outputs are compared, relative rewards assigned within the group — no separate reward model needed, more stable training.
Used to train R1-style reasoning on financial problem-solving datasets
Reward is given only for verifiably correct answers (math, code, logic). No human judges needed — correctness is the reward signal. Key innovation behind DeepSeek-R1's reasoning.
Train on financial calculations with known correct answers: NAV calculation, duration, convexity
Deep Agents — Long-Horizon Autonomous AI
Updated Oct 2026Module 4 covered the fundamentals of AI agents — the loop, tools, ReAct, frameworks. Deep Agents are what happens when those fundamentals are pushed to their limit: agents that run for hours or days, handle complex multi-stage goals, recover from their own failures, and coordinate entire workflows end-to-end with minimal human intervention.
The Core Distinction
Standard Agent
- • Single well-defined task (summarise this document)
- • Seconds to minutes to complete
- • Fixed set of tools known upfront
- • Fails gracefully, asks user for help
- • Human reviews every output
Deep Agent
- • Complex, open-ended goal (research this company, build this feature)
- • Minutes to hours to days to complete
- • Dynamically discovers what tools/steps are needed
- • Self-diagnoses failures, retries, replans
- • Human reviews key checkpoints, not every step
Deep Research Agents
The most widely deployed class of deep agents today. Given a research question, the agent autonomously searches, reads, synthesises, and produces a cited report — in 5 to 30 minutes — at a depth that would take a human analyst hours or days.
GPT-4o/o3 based. Browses the web autonomously, reads full articles, synthesises across 20–50 sources. Produces a multi-page cited report. Launched Jan 2025 — immediately became the benchmark.
Research a target company for M&A: financials, news, regulatory filings, competitor landscape — in 20 minutes.
Google's equivalent using Gemini 2.0. Integrates natively with Google Search and Scholar. Strong on finding recent news and academic sources.
Monitor regulatory changes across 15 jurisdictions overnight. Deliver a morning briefing on what changed.
Research-focused platform. Faster than OpenAI/Google — lighter synthesis but strong real-time web search. API available for integration.
Daily market intelligence brief: synthesise overnight news across equities, rates, and macro in under 5 minutes.
# Build your own Deep Research agent — finance edition
import anthropic
client = anthropic.Anthropic()
RESEARCH_SYSTEM = """You are a senior financial research analyst.
Given a research question, you will:
1. Break it down into specific sub-questions
2. Search for information on each sub-question
3. Read and synthesise the results
4. Identify gaps and search again if needed
5. Produce a structured report with citations
Always cite sources. Flag uncertainty explicitly.
Never fabricate data — if you can't find it, say so."""
def deep_research(question: str, max_iterations: int = 10) -> str:
messages = [{"role": "user", "content": question}]
tools = [web_search_tool, read_page_tool, calculator_tool]
for iteration in range(max_iterations):
response = client.messages.create(
model="claude-opus-4-8", # use most capable model
max_tokens=8096,
system=RESEARCH_SYSTEM,
tools=tools,
messages=messages,
)
if response.stop_reason == "end_turn":
# Agent decided it has enough — extract final report
return extract_report(response)
# Agent wants to use tools — execute and continue
tool_results = execute_tools(response.content)
messages.extend([
{"role": "assistant", "content": response.content},
{"role": "user", "content": tool_results},
])
return "Research incomplete — max iterations reached"
# Finance example
report = deep_research(
"Analyse HDFC Bank's credit quality trends Q3 2025: "
"NPA ratios, provision coverage, sector concentration, "
"and management guidance versus analyst consensus."
)Agentic Coding — Software Engineering Agents
Agents that don't just write code snippets — they understand an entire codebase, plan multi-file changes, write tests, run them, debug failures, and iterate until the task is complete. The 2025 step-change from Copilot (autocomplete) to autonomous engineering.
Full terminal access, reads entire repos, writes and runs code, runs tests, commits. Used in agentic mode for multi-hour tasks.
First commercially deployed 'AI software engineer'. Given a GitHub issue, it plans, implements, tests, and raises a PR. Works across many hours.
Given a GitHub issue, generates a plan and full implementation across multiple files. Reviewed by developer before merge.
Cloud-based agentic coding — runs in a sandboxed environment, can execute code, install packages, and iterate.
Finance Applications
Self-Healing Agents — Autonomous Error Recovery
A critical capability for long-horizon tasks: the agent detects when something went wrong, diagnoses the failure, and replans — without human intervention. This is what separates agents that are genuinely useful for multi-hour workflows from those that get stuck at the first obstacle.
Self-healing patterns:
When a tool call fails (API timeout, invalid data), the agent catches the exception, reasons about why it failed, and tries an alternative approach — different tool, different query, different source.
Agent generates output, runs a validation check (schema check, sanity check, completeness check). If validation fails, the agent understands the failure message and self-corrects.
For very long tasks, the agent saves progress at key milestones. If interrupted or if a step fails, it resumes from the last good checkpoint rather than starting over.
When the agent genuinely can't resolve an issue after N retries, it escalates to a human — but with a full summary of what it tried and why it failed. Not 'error occurred' — 'I tried X, Y, Z; each failed because...; I need you to resolve W'.
# Self-healing agent pattern
async def run_with_recovery(agent, task, max_retries=3):
context = {"task": task, "attempts": [], "errors": []}
for attempt in range(max_retries):
try:
result = await agent.run(task, context=context)
# Validate output before returning
if not validate_result(result):
error = f"Validation failed: {get_validation_error(result)}"
context["errors"].append(error)
# Agent sees its own validation failure
task = f"{task}
Previous attempt failed: {error}
Please fix."
continue
return result # success
except ToolCallError as e:
# Tool failed — let agent know and replan
context["errors"].append(str(e))
context["attempts"].append(attempt + 1)
task = f"{task}
Tool '{e.tool}' failed: {e.reason}
Use an alternative approach."
except Exception as e:
context["errors"].append(str(e))
# All retries exhausted — escalate with context
return escalate_to_human(task, context)Long-Horizon Agent Patterns
Before starting a long task, the agent produces a complete plan and submits it for human approval. Once approved, executes step by step. Human reviews at key gates, not every step.
Fund NAV reconciliation: agent plans all steps → compliance officer approves → agent executes overnight → delivers exception report by 6am
Decompose a large task into independent subtasks, spin up parallel sub-agents for each, aggregate results. Dramatically reduces wall-clock time for research and analysis tasks.
Due diligence on 20 target companies simultaneously — one sub-agent per company, parallel execution, orchestrator synthesises
Agents that run continuously in the background — monitoring, checking conditions, taking action when triggered. Not single-shot — they persist across time.
Compliance monitoring agent: watches transaction feeds 24/7, flags anomalies in real time, drafts SAR reports when threshold breached
Deep Agent Use Cases in Financial Services (2026)
Given a target company, agent reads 10-Ks, earnings transcripts, news, court records, competitor filings. Produces a structured DD report with flagged risks. Human partners review and validate.
Persistent agent monitors SEBI, RBI, IRDAI, SEC, FCA, ECB publications. When a relevant circular is published, agent reads it, maps obligations, updates the compliance calendar, and sends a briefing to the team.
Agent gathers data from bureau, bank statements, GST filings, property records. Calculates ratios. Assesses risk against policy. Produces a recommendation with supporting evidence. Underwriter reviews and decides.
Agent runs portfolio through 50 stress scenarios, calculates VaR, CVaR, drawdowns under each. Identifies top risk concentrations. Generates the regulatory stress test report. Quant reviews outputs.
Agent reads the break ticket, queries settlement systems, reconciles trade records across counterparties, identifies the root cause, drafts a proposed fix. Ops team approves the fix.
Agent orchestrates checks across bureau, sanctions databases, PEP lists, adverse media, GST portal. Generates risk rating. Compliance reviews the consolidated report and makes the final decision.
Governing Deep Agents — The Hard Part
Deep agents introduce governance challenges that standard agents don't have. The longer the horizon, the more consequential a mistake, and the harder it is to trace accountability.
Full trace logging of every step, decision, and tool call. Not just the final output — the entire reasoning chain must be stored and queryable for audit.
Early checkpoint gates with human review. If step 3 of 50 has a bad assumption, the agent carries that error through 47 more steps. Catch it early.
Every consequential action (payment, data access, external communication) must have an explicit human approval in the audit trail. The human is always accountable, not the agent.
Strict tool allowlists per task type. Agent cannot acquire new tools mid-task. Read-only by default; write actions require explicit per-task authorisation.
Define clear memory and data retention policies. Agent memory is personal data under GDPR/DPDP. Right-to-delete applies. Scope memory to task duration, expire it.
Deep research agents read many external documents — each is a potential injection vector. Spotlighting + Prompt Shields on every document chunk retrieved. Dual-LLM pattern for high-risk tasks.