Get the Monday email →
Loading player…

From Idea to Agent: Infrastructure and the New Pace of Agentic Development | DC Fintech Week 2026

DC Fintech WeekMon, Nov 2, 2026, 12:00 AM

A behind-the-scenes look at how a complex financial workflow became a working AI agent and at the infrastructure underneath the agentic economy: how agents are developed, deployed, and permissioned at cloud scale, and what that architecture means when agents operate inside regulated financial systems, where every action must be authorized, auditable, and traceable to its source. • Chris Knott, Head of Solution Architecture, Federal Financial Services, Amazon Web Services

Transcript

Good morning. Welcome back to HQ2. Amazon has hosted FinTech week here for years, and it's great to have this amazing group of innovators back in the building. My team in Amazon helps our government and regulated market customers across the globe adopt new and the latest AWS technology. In the years past, we've showed you demos of what was coming.

This year, I want to do something a little different. I want to share a story of what we've learned in the last year from our customers who are building agentic solutions. The practice, what works, what breaks, and how to deliver faster inside a regulated institution. My name is Chris Knott. I lead federal financial solution architecture.

Let's get into it. First, let's talk about high-judgment work, where expertise is scarce, takes years to build, and the stakes are high. The analysis behind each judgment call is tedious. In financial supervision, that means findings, exam comments, remediation items. One institution can be sitting on hundreds of matters requiring attention or more across a dozens of exam teams, thousands of pages, years of history.

Here's what customers tell us. The hard part was never finding the issues. Subject matter experts like examiners are exceptional at that. The hard part is knowing which one is the one. Which finding, buried among hundreds, is the warning before the earthquake?

You can't solve this simply by adding people. Every new person adds capacity, but also a coordination cost, while the volume keeps compounding. This is where agents are changing the landscape and the equation. Not by replacing the expert, but by extending them. This summer, our team was asked to join and help a team of experts build.

In 14 hours, using public information, synthetic data, we built a working agentic solution for this exact problem. The team calls it exam signal. Let me walk you through it. This is the pile. 200 findings across 20 institutions.

The question is simple. Which one should a person open first? Here is one finding at one bank. It scores 100 out of 100. That's material.

Here is how it got there. We didn't build one single agent. We split that job across three agents. The first agent reads the record. It's routine work, so a small fast model is used.

The second agent studies the bank health. The judgment? It uses a large model for that complex reasoning. Its determination? The bank is in serious trouble.

That third agent does not guess. It takes both of those hand-offs and calls the scoring rules as a tool. Every point traces back to evidence. 100, well over the line. And the last step is not an agent, it's a person.

In this scenario, same process, different finding. So, we're using the same agents, same kind of finding. This The difference is this is a healthy bank. Same process. The first agent hands off almost the same facts, but the second agent's news is good.

So, the points come to zero. Overall 32, that's not material. So, at the end of that, same rules, same agents, different evidence, different answer. Even in a close call, 46, two points under the line, it's too close to trust. So, we mark it as low confidence.

As always, it goes to a human to review. In this case, the examiner overrides it to a material risk and writes down the reasoning behind that change. The The recommendation and the decision sits side by side. Every action then lands in an audit log that can be discovered later. Each of those agents is built from the same four parts.

Let's talk about what an agent actually is. An agent is software that can reason, plan, and act to accomplish a goal. At its core, it starts here. A model doing the reasoning. It takes a goal, loops through options, and decides what to do next.

But, the point is not a model. It's making sure you're using the right model for the right job. Different tasks need different models, and that mix can shift over time. A core architecture principle in the GenAI world, keep the freedom to choose and swap models. A model alone is smart and blind.

To be useful, an agent needs context. That's simply what is happening, what it knows, what it remembers. This is where we are seeing customers make leaps since we got together last year. Managing context is what lets agents reason about your business, not just the world in general. But then it has to act.

Tools let the agent do something, calling an API, updating a record, starting a workflow. Reasoning plus context plus tools, that's what turns a chatbot into something that actually gets work done. And notice the complexity is building. In production, you don't have a single agent. You have many agents calling many tools touching lots of data all at once.

Building one agent is a weekend. Running a fleet of them safely in production, that is where customers are learning the fastest. Everything I just described, the models, the context, the tools, a fleet of agents together, you cannot manage this and operate it piecemeal. If you wire it by hand, every layer becomes its own project. The hard parts, security, isolation, coordination, they don't simply show up in a demo like that, but they decide whether or not you can actually move that solution into production.

That's why we're seeing the rise in agentic platforms. At the left, you bring the reasoning. Any model, any agent framework or harness. To the right of that, the context. The memory and the data that ground the agent.

Then tools, one governed gateway to your systems. Lastly, visibility. This is the area we all need to invest to have observability of every decision and every action performed by that agent. Underneath secured execution, the runtime, the identities, and the policies that decide what agent can touch what data and perform what function. The platform is what let a small team stand on top of all that machinery instead of building it.

And this is the clearest lesson from last year. The teams that I'm seeing reach production faster start on a platform that reduces heavy undifferentiated lifting. The platform gave us somewhere safe to build and run Exam Signal. But the team still had to build it. In days, not months.

How does a two-person team do that? They used agents to build. The team set the direction and they drove the agents. The agents did the work, though. That changes what development is.

Three shifts. First, autonomy. Agents reason and solve problems. So, we hand them a whole technology task, not just a single prompt. Not write me this function, but build me this capability and come back when it holds together.

That frees our people for these higher judgment calls and activities. The second, collaboration. This is the part people underestimate. An agent is a true collaborator. Not an assistant that waits for your next keystroke, but a colleague that takes the intent, carries that work forward, and comes back with something to review.

We set the direction. The agent does the build, and we step in where judgment matters. Third, higher quality. Agents take on the work teams run out of time for. Documentation, test coverage, security fixes.

The quality of these releases go up as technical debt comes down over time. That is a monumentous shift. Not just faster typing, but a whole new way of building. And if the agent is the collaborator, the question is how do you direct it? You give it a spec.

Exam signal is one solution that encompasses many agents, but the bigger shift is how do we build now with these new concepts? We start with a spec. A clear statement of what we want, including the security guardrails that reflect how we develop. From there, the agents handle the development life cycle, but people will stay in control. A human reviews the requirements, approves the design, and signs off before anything ships.

This is spec-driven development. The human sets the spec and the agent holds the code to it. AI DLC. This is a pattern and not a one-off. It's a repeatable way of building and running collaborating agent.

So, when we think about the AI-driven development life cycle, we think about traditional software and the five phases it moves through. Requirements, design, development, deployment, support. AI DLC collapses those five into three. Inception, construction, operation. In inception, requirements and design happen together.

In construction, agents build in short iterations. Think hours or days, not weeks. In operation, it runs in production. Through all three, the same pattern emerges. The AI proposes, a human reviews, the AI executes, the human validates.

Teams see 30 to 50% less time from idea to production with fewer defects using the AI DLC framework. AI-driven software development is how two people shipped this solution in 3 days. I opened the conversation with a challenge. The signals are there, but we can't surface them in real time. The problem is not a lack of expertise.

It's that human judgment cannot keep up with the volume we receive. We can extend our best people instead of burying them by embracing these new principles. We can catch the early warning before the earthquake. Everyone in this room has a high judgment problem worth solving today. So, the question is not whether to adopt agents, it's what would you point them out first?

Find out what these tools can build in the hands of your experts. Really appreciate the time today. Thank you so much.

Automatic transcript — names and jargon may be misspelled.