We rebuilt F2's deal agent from the ground up. Adam reads full data rooms, builds models in Excel, and writes memos and decks on your firm's own templates, with every figure cited to the exact data room page or past deal it came from.
Underneath Adam 2.0 is a new architecture we call the adaptive harness: the software built around the model that reshapes Adam to each task, to your firm’s knowledge, and to every new generation of models.
How Adam 2.0 has improved
Adam 2.0 changes how your team works every deal, end-to-end:
- Adam owns the work. Adam works your deal itself and decides when to bring in help from other sub-agents. Any sub-agent starts from an indexed copy of the full conversation rather than a short brief, so the request you make is the request that gets done.
- Exact figures now survive long threads. A figure such as $47.2M Adj. EBITDA, cited to page 14 of the QoE, comes back exactly as it was whether you ask on the first request or the fiftieth.
- Your templates, copied by reference. Memos, models, and decks start from your firm's own files, so fonts, number formats, and layouts look and sound like you.
- Adam now checks every deliverable before calling it finished. Formula errors, clipped text, and a rendered view of every tab, slide, and page.
- Your precedents and standards shape every output. Past IC memos, credit agreements, and models from the deals your firm has closed inform the next one, and every correction you make stays with you.
- Your workflows carry over as the models change. Adam works on frontier models from several providers, including open-weight models, and your skills, templates, and memory stay the same when a better model arrives.
How the adaptive harness works
Every AI agent has two parts: the model that reasons, and the software around it that decides what the model sees, which tools it can call, how it tracks a long conversation, and how its output becomes a real file. That software is the harness. Most industry attention goes to the model. In our experience, though, work that spans a long thread, hundreds of documents, and several deliverables depends on both: the model’s reasoning, and a harness that keeps it supplied with the right context and checks what it builds.
Adam’s harness describes rather than directs. The instructions and tool descriptions Adam reads tell it what each tool can do, what it returns, what it costs, and what a finished deliverable looks like; Adam decides the order of the work itself. When Adam gets something wrong, we improve the description or the tool it was working with, rather than writing a new instruction telling Adam what to do in that situation.
Every skill, standard, precedent, correction and closed deal your firm adds becomes part of a structured, connected record of how your firm works and decides (in effect, your firm’s context graph), and that record grows every time your team works with Adam. A harness that scripts its steps in advance cannot keep up with knowledge that changes with every deal; one that assembles each request from the current state of that knowledge can.
Every time you send Adam a request, the harness does three jobs before Adam answers:
It assembles what Adam sees
Each request starts from a small, fixed core of instructions that never changes, so the model provider can store it and skip re-reading it (what we call “prompt caching”), which keeps Adam fast. Around that core, the harness assembles everything else Adam will read fresh for that request:
- You: your User Memory, the units, formats and sections you always want.
- The deal: Deal Memory, its current overview and the latest timeline entries.
- Your firm: a ranked catalog of your firm's skills, your Firm Standards and your firm's instructions to Adam.
- Your past deals: Institutional Knowledge, precedents from the deals your firm has closed, which the harness brings in when the work calls for them.
- Live state: files still processing, and how much of the text Adam can hold in view at once is already in use.
None of this lives in the model or in that fixed core of instructions, and none of it takes fine-tuning or a custom build.
It lets Adam choose the path
Every tool describes itself: what it does, what it returns, and what it costs. With that, Adam makes decisions that a fixed harness would have settled before the work began:
- How deep to go. A lookup gets a quick answer. An IC package gets research, a model, a memo, and a deck.
- Which skill to load. Skills, such as how your firm builds a screening memo, load only when the task calls for one.
- Whether to bring in help. For big jobs, Adam spawns a team of sub-agents that work in parallel, each at the effort its job needs. Each starts from a complete, indexed copy of the conversation rather than a written summary that drops detail.
- What to keep in view. Adam watches how much of its working view it has used and decides when to set older material aside, at a natural break in the work. Compaction keeps a summary plus an indexed catalog of everything set aside, and Adam can pull any item back word for word, so exact figures and their sources return intact.
It checks the work before Adam calls it finished
A deliverable isn’t done because the model says it is. Adam builds every workbook, deck, and Word report by writing a script, and the harness can check a script in ways it cannot check a finished file. So quality control happens through automatic checks rather than the model’s judgment.
Before anything reaches you:
- Nothing invalid gets built. The harness checks each script before it executes, so a mistake fails loudly instead of quietly vanishing.
- No new broken formulas. Every workbook change reports any formula errors it introduced.
- No clipped or overlapping text. Layout problems block Adam from calling the work finished.
- Edits stay in scope. Every change to a Word report states what it may touch, and the harness refuses anything outside that, so approved text and your template's tables can't drift.
- Nothing ships unseen. Adam reviews a rendered view of every tab, slide, and page, exactly as you'll open it, and decides which ones need a close read.
And when Adam can’t be sure, it says so. Adam flags missing data, a failed request, or an ambiguous company name rather than filling it in, and every figure cites the page or past deal it came from.
How Adam adapts to your firm's format and precedents
Two firms using Adam 2.0 get two different agents. A direct lender’s Adam would open every screen with its covenant checklist, build in its EUR model template, and cite its own unitranche deals as precedent. A special situations fund’s Adam would lead with liquidity runway and recovery and reach for its own distressed precedents.
Your format, the first time. Adam starts the work from your files instead of recreating your format from a description. That holds at two layers, so every deliverable is on brand whether it comes from a defined skill or a one-off request:
- Skill templates are authoritative. A skill captures your firm's process once: instructions, reference files, and the deliverable it produces. It can carry its own template, such as the firm's screening memo, model layout, or IC deck. When a skill loads, Adam starts from that template and fills it with data from the data room, keeping the structure, tables, and design intact.
- Firm Standards are the fallback. For anything without a skill template, Firm Standards for reports, sheets and decks supply the firm's fonts, colors, number formats and page layout, so even a one-off analysis comes out looking like your firm made it.
Formatting is an engineering problem. Telling a model to "match the template" fails: it guesses, and every edit drifts further. So Adam copies formatting by reference: it carries the complete styling of a range in your own file onto the new work. We also fixed the code that draws the file. In our tests, one firm’s navy kept coming out pale blue; we worked on the rendering until that firm’s cap table template copied with zero style mismatches.
Adam becomes more yours over time. Every correction you make updates your User Memory, which stays private to you. Every thread adds to Deal Memory, which the whole deal team shares, so the next thread starts where the team left off. The skills your team actually uses rise to the top of the catalog, and every deal you close becomes a precedent for the next.
Where your firm's knowledge lives
Every credit firm now has access to the same frontier models, so the advantage moves to what only you have: your precedents, your IC memos, your credit agreements, your standards, and the judgment your team has built over hundreds of deals. Any firm adopting AI has to decide where that proprietary knowledge will live.
That decision shaped the architecture. Your firm's knowledge stays in your firm's own F2 environment and never enters a model.
- Knowledge stays in your firm. Skills, templates, standards, Deal Memory and precedents sit in your F2 environment, isolated from every other firm. The model reads them only when a request task needs them, and only for that request. No training on your data, zero data retention.
- Model-agnostic by construction. Adam works with frontier models from several providers, including open-weight models, and routes each task type to the best-suited model. Because your workflows, skills, and memory belong to the harness rather than to a model, they carry over unchanged as models improve.
Getting Adam 2.0
Adam 2.0 is now live for F2 customers. Your previous threads will stay on the previous Adam, so nothing changes mid-conversation; customers can start a new chat to work with Adam 2.0 today.
Firms new to F2 can be up and running within 48 hours and can book a demo to see Adam adapt to their own templates and precedents. More than 100 private credit funds and commercial banks already underwrite on F2.
