From Prototype to Production: Building nCino's Credit Analyst Sub Agent

How six years of domain knowledge turned a workshop prototype into a production banking agent — and what I learned about where agentic AI actually works.

Most “AI agents” I’ve seen are a persona wrapped around a language model. They talk like they’re doing something impactful. They usually aren’t.

The nCino Credit Analyst Sub Agent actually does something. An analyst uploads a tax return, gives a one-line instruction, and the agent extracts the financials, creates a spreading period, pauses for human review, then generates a credit analysis summary. About a minute, end to end. In production. At a real bank.

I built this. I want to talk about how it went from a workshop experiment to a shipped product, and why I think the difference between “agent that sounds smart” and “agent that does useful work” comes down to domain knowledge and tool design, not model capability.

The Workshop

In mid-2024, I got pulled into an internal workshop focused on nCino’s agentic AI capabilities. It was a rare chance to step away from the backlog and just build something.

The first thing I built wasn’t the full Credit Analyst Sub Agent. It was a pair of summary tools — take a locked financial period and turn it into a usable financial analysis. A much smaller slice of what eventually shipped, but the first moment where the idea felt real.

We already had AutoSpreads at this point. It uses OCR and AI extraction models with a mapping UI on top of tax forms to move data into the spreading workflow. Customers use it, it works well. But the mapping interface is heavy, and the flow still requires an analyst to navigate multiple screens and verify mappings manually. So: what if we kept the extraction intelligence but removed the UI entirely? What if the agent just did the work and handed you the result?

The Prototype That Got Attention

Early 2025, I started building it. A no-UI version of autospreading — use the newer tax statement AI models to pull data from a return and write it directly into the spreading workflow. No mapping screen. No intermediate steps. Upload, extract, populate.

Once that piece worked, the summary tools from the workshop snapped into place. Suddenly you had a flow: tax document in, structured financial period out, analysis summary generated. The whole thing took about three minutes.

That got attention fast. A cross-functional team formed around it. By April we had a working demo. Ben Miller, our Senior Manager of Product Management, called it “a big step toward the dream state of financial analysis.” A video of the prototype played on the main stage at nSight 2025 during the Banking 2030 keynote.

By October, we were in formal productization. I led the engineering effort with a dedicated team to harden the workflow, shape the tool boundaries, and ship it through nCino’s release cycle. March 2026: first production deployment at an enterprise financial institution.

What It Actually Does

From the analyst’s chair: upload a tax return, open Banking Advisor, tell the Credit Analyst Sub Agent to analyze it.

Behind that chat message, ten purpose-built tools do actual work across multiple internal platforms. The agent extracts structured financial data from the tax document. Creates a spreading period. Writes the data in. Then (and this is the part I care most about) it stops.

It surfaces a link to the familiar Spreads interface and waits. The analyst reviews the extraction. Checks the numbers. Applies their judgment. Only after they confirm does the agent lock the period, generate a financial analysis summary, and surface key metrics — debt service coverage, current ratio, debt-to-worth — directly in chat.

What could take upwards of thirty minutes even with existing tooling was now done in sixty seconds.

That pause is not a limitation. It’s the entire point. If an agent is writing financial data into a production banking system, it needs to know when to stop. The goal was never to remove the analyst’s judgment. It was to remove the repetitive data entry and system navigation that comes before they get to use it.

Why This Isn’t Another Chatbot

I said it at the top but it’s worth expanding: most agent demos don’t actually do anything.

The Credit Analyst is different because the value isn’t in the chat interface. It’s in the tools. Each one is a direct interface to a real banking system — creating records, calling extraction models, triggering downstream workflows. The agent orchestrates those tools in sequence, handles errors, knows when it’s blocked, and knows when to hand control back to a human.

That’s also why domain expertise mattered so much here. I didn’t need to guess which parts of the workflow should be automated and which shouldn’t. I’ve known analysts are still doing tedious data entry work for years. I knew where the pain was, and I knew where the judgment was. And they were on completely different sides of the workflow.

Someone building this from the AI side first — starting with “what can a language model do?” rather than “what does an analyst actually need?” — would have built something very different. Probably something less capable or more dangerous. I believe our system has the right balance of capability and human involvement.

The Timeline

Mid-2024 — Built the first financial summary tools in a workshop

Early 2025 — No-UI autospreads prototype, new tax statement models

April 2025 — Working demo: tax document to risk summary in minutes

May 2025 — Video on the nSight 2025 main stage

October 2025 — Productization begins with a dedicated team

March 2026 — First production deployment

The original shape of the idea survived more intact than I expected. Even after architecture hardening, team handoffs, putting the project down, and picking it back up months later — I can still see those first workshop tools inside the finished product.

A view from the Community Lounge at nSight 2026.

nSight 2026

I presented at nSight 2026 in a product pod during a session called “The AI-Powered Credit Team Across the Commercial Lending Lifecycle,” where I gave a live demo of the agent turning a tax document into a financial analysis in real time.

After walking through the user-initiated journey, I opened a new tab to show the fully autonomous version. I uploaded a document, then the agent ran in the background, and about a minute later I was notified that my analysis was ready — the agent showed me the numbers and sent a request to confirm I was satisfied.

The version of AI I’m most excited about isn’t the one that replaces people. It’s the one that gives them their time back. The agent collapses the workflow between “I have a tax document” and “I’m ready to make a credit decision” into something that takes a minute instead of a session.

There’s a lot more to build. But it works, it’s in production, and its mine in the way only a few projects in a career really are.

The Team

I said "I built this" at the top, and that's true for the original prototype. But the production product was a team effort. The people who shipped this with me: James Abbott, Stuart Weaver, Deepa Sekar (engineering), Nishanthini Rajendran Santhinirmala (QA), Alice Whitworth (product), Ben Miller (product), and Kiran Kotresh (engineering management). Good software is a team sport. I'm really grateful for all the people that helped turn the vision into a reality.

About The Author

“Curious by default. Allergic to AI that doesn’t do anything.”

Phillip Byram is a Senior Software Engineer at nCino, building production agentic AI for commercial lending. Six years inside the banking software stack, an IC who works across product, engineering, and AI/ML to ship agents that do real work — not ones that just talk about it.