Build Your Own Finance Agent Inside ChatGPT - Stefano Fabbri & Oliver Steffmann, OpenAI

Loading slides…

Read the talk

From a Portfolio Move to a Client Meeting: Building a Finance Agent Inside ChatGPT

Three columns pair ChatGPT with “Explore a question,” ChatGPT Work with “Complete a task,” and Codex with “Build the method,” each with an example prompt.Open full source frame
Choose the surface by what the finance team needs to do. Use ChatGPT to explore what Rachel should ask about Jordan’s renovation plans, ChatGPT Work to prepare the review using client records and cited company research, and Codex to create and test a reusable advisor-review skill.

Stefano Fabbri and Oliver Steffmann use a wealth advisor’s meeting preparation to show how ChatGPT retrieves financial evidence, where reusable skills shape the analysis, and when a firm needs to connect its own tools through Codex.

From a talk by Stefano Fabbri and Oliver Steffmann

At a glance

Ideas worth remembering

  • Try the supplied finance workflow against one client case first. Follow the evidence from portfolio change through P&L or attribution into the explanation the advisor needs for the meeting.

  • Match the customization to the missing capability. Use a skill for a repeatable procedure, an MCP-backed plugin for access to firm tools or data, and a desktop plugin extension for an interactive view.

  • Carry the meaning of a financial value with the value itself. A price, a return, and a delayed observation support different claims even when they refer to the same security.

  • Verify both the tool call and the execution environment. The workshop’s web interface exposed which finance plugin ran, while the integrated financial data was unavailable to a Codex CLI pipeline.

  • Prototype an internal portfolio or customer lookup in local Codex, then verify which data sources the advisor’s actual ChatGPT or Codex surface can reach and whose identity the tool will use.

  • Package a recurring method such as portfolio analysis with examples of the finished workbook or presentation. Use discrepancies in real outputs to refine the shared skill and retest it when changing models.

  • Measure delegated tasks separately from planning. A cheaper model may handle a well-specified report, while a faster model does little for a repository scan that consumes the laptop’s compute.

  • In a research workflow, give the critic two jobs: check coverage of the original questions and dispatch a targeted investigation when independent findings conflict.

  • Prototype the research procedure where the researcher can change its sources and checks. Use the Codex SDK when the same work needs to run on a server or behind a dedicated interface.

  • Before distributing a desktop extension, specify the project files, network destinations and tools it needs. Use enterprise policies to set those boundaries and decide which actions require approval.

Start with the advisor’s work and provision a financial workspace

A wealth advisor has to explain why a client’s portfolio changed and what it would take to bring it back into balance. OpenAI’s Stefano Fabbri and Oliver Steffmann chose that assignment for a two-hour workshop with people from asset managers and investment banks. It gave them a way to test several capabilities together. Could an advisor get the relevant financial data, use a model to understand what happened, and carry the evidence through to a presentation they could use with the client?

Fabbri introduced the pair as members of OpenAI’s customer-facing applied AI team. Much of his work was with financial institutions in New York, helping them put models into production and get value from what they spent on them. Steffmann brought experience in asset management and investment banking, along with a developer’s interest in what a firm could build on the platform. Their colleague Dom was in the room to help participants individually. The split in experience informed the agenda. First, use the product as an advisor would. Then, take the internal developer’s seat and decide what to add.

The first action was to scan a QR code and provide an email address. OpenAI used it to grant access to a dedicated workspace with financial data and unlimited tokens for the session. The organizers also enabled an ultrafast mode for GPT-6.1 Sol and GPT-6 Astra. Fabbri put average generation speed in that mode at about 300 tokens per second. The immediate benefit for participants was shorter waits as they tried prompts and generated material. It was a figure for model output speed, separate from the age of the market data they would retrieve.

Fabbri budgeted about ten minutes after the introduction to get everyone into the workspace. Steffmann would lead two practical sessions, beginning in ChatGPT Work and then moving to Codex. The organizers reserved the final twenty minutes for questions about both the engineering and its use in financial institutions. Participants could ask for help as they went, which mattered because getting onto the workshop site and getting access to the financial product involved separate steps.

0:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:12 · section reference included

Three interfaces and three ingredients of the financial product

Fabbri distinguished three interfaces. ChatGPT was the original general-purpose product. ChatGPT Work was the environment aimed at knowledge workers, with agents and plugins available in the course of their work. Codex was oriented toward engineering tasks. A business user could work in Codex, as Steffmann would later point out, but the sequence here was deliberate. An engineer could first see what an advisor could accomplish in ChatGPT Work before deciding that the firm needed more software.

Fabbri described ChatGPT for financial services as an enterprise product built on the same underlying model as ChatGPT. He distinguished three parts of the offering. The first was data access. Some financial sources were built in, and users with access to other providers could query those sources through ChatGPT. The second was the model’s proficiency at financial tasks. Fabbri said OpenAI had trained the model on work such as mergers and acquisitions and equity analysis. Retrieving a filing supplies the evidence. Interpreting it for a valuation draws on that financial training.

The third part was producing artifacts. An analyst may need a spreadsheet that another person can inspect or a presentation suitable for a meeting. The model could use a historical example as a template, carrying its format forward into a new analysis. That makes the old presentation useful even when the underlying numbers have changed. It supplies an example of how the team communicates its work.

Steffmann identified what to look for when using the finance plugin in the web interface. Beyond fetching a figure, it could guide the model in choosing how to chart the information, validating the data, and adding notes about its origin. Those instructions matter at the point where a result moves from a conversation into a deck. An advisor explaining a chart needs to know what its series represents and where the values came from.

4:57
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:57 · section reference included

What the finance workspace supplies before a firm connects its own data

The dedicated workspace gave participants access to a product Fabbri said was available to enterprise customers. He named Daloopa, LSEG, PitchBook, and Crunchbase among the providers OpenAI worked with. The available material spanned SEC filings, market data, news, private-company profiles, and earnings transcripts. These sources answer different parts of an analyst’s question. A market series can establish that a price moved. A filing or an earnings transcript gives the analyst material to investigate an explanation for the move.

An enabled financial-data menu lists nine categories. A table beside it pairs eight sources with the filings, transcripts, company metrics, news, and market data they supply.Open full source frame
A deep dive on financial data

Fabbri estimated that the market data was delayed by about fifteen minutes. For the meeting-preparation case, that qualifies what an advisor can say about a recent observation. Even a model that produces an answer in seconds is working with a price from the time represented by the source. Fabbri gave the delay as an approximation and did not break it out by provider or instrument.

The integration also changed what the model received. Fabbri said the team had repackaged the datasets into forms the model could consume more readily and had seen a significant improvement in how it used them. Steffmann recognized the engineering work from an earlier effort in asset management. Downloading SEC files was one job. Handling the collection at scale and continuing to bring in new information were recurring jobs. He pointed to agents continually collecting data and to a layer of context that made the resulting material usable at speed. Later questions would get much more specific about what belonged in that context.

7:52
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:52 · section reference included

Use an investment-banking or equity-analysis plugin as a starting procedure

Fabbri described a finance plugin as a library of skills packaged with Model Context Protocol (MCP) connections. The skills give the model procedures it can reuse. The connections give it tools with which to carry out parts of those procedures. OpenAI had worked with investment banks, asset managers, and equity analysts on the contents of the skills. The goal was to give a practitioner a recognizable starting method for an assignment that would otherwise require considerable instruction.

Consider an equity analyst with a recurring assignment. Fabbri suggested starting with a supplied skill, using it as the basis of a scheduled task, and seeing how closely the resulting process matches what the analyst wants to repeat. At that point, the analyst can identify the missing instructions and adapt the procedure to their own requirements and views. Fabbri used an informal 80/20 split to describe the division of effort. Industry knowledge might get much of the base in place, leaving the practitioner to supply the last part. He offered that as a way to think about customization, without claiming a measured completion rate.

The ready-made examples leaned toward investment banking. They included preparing presentations, analyzing earnings, performing valuations, and building leveraged buyout (LBO) models. The day’s exercise would instead follow wealth management, where the immediate question concerned a particular client’s portfolio. One of the presenters recalled having discussed asset valuation with bankers despite already knowing capital markets. Trying the plugin on a few local examples helped him understand more quickly the problem those customers had been describing. Running a recognizable case gave the practitioner something concrete to compare with their own method.

Five labeled screenshots show an LBO model with adjustable assumptions, a buyer screening table, a valuation spreadsheet, a pitchbook page, and an earnings forecast chart.Open full source frame
Use cases your team can get started with
10:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:08 · section reference included

Follow the change from the client’s portfolio into the meeting deck

As participants confirmed that they could sign in, the presenters directed them to the workshop site. A QR code led to the development material, with an access code available if the site requested one. They allowed time for people to get in before proceeding. Meanwhile, Steffmann explained what the advisor was supposed to accomplish with the financial data and the supplied guidance.

The starting event was a change in a client’s portfolio. The team preparing the meeting had to examine the portfolio, work out what happened, explain it, and prepare material for the advisor. Steffmann specified a profit-and-loss statement or a portfolio attribution as the analytical output. These give the advisor different ways into the conversation. A profit-and-loss statement establishes the gain or loss. Attribution addresses which parts of the portfolio contributed to the result. A market move takes on meaning for this client through what the client held.

The next output was a presentation explaining the change and what the advisor could discuss with the client to restore balance. The analysis and the deck therefore had to agree. If the advisor wanted to discuss a particular holding, the preceding work had to establish why that holding mattered to the portfolio change. The exercise supplied a scenario and prompts, leaving the advisor’s team room to use its own working method. Steffmann had seen considerable variation in how advisors prepared for meetings.

The business objective was more time for the advisor and client to spend together. That put a useful boundary around the engineering exercise. Portfolio research, explanation, and meeting preparation were all candidates for assistance because they consumed time before the conversation. The deck was intended to equip the advisor to conduct that conversation. At this point the presenters had specified the assignment and its intended outputs. They had yet to show a computed attribution, a particular rebalancing recommendation, or a finished client presentation.

13:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:07 · section reference included

Choose between a separate API application and an extension of the existing workspace

Steffmann asked how many participants were developers, engineers, or otherwise involved in technical development. He estimated about half the room. For them, he recast the case as the next request an internal engineer might receive. Suppose ChatGPT has already landed successfully in the finance department. Business users now want it to work with the firm’s data and to fit the way their own teams operate. What should the engineer actually build?

One option was a conventional application. Obtain an OpenAI API key, build a web interface, use Codex to help implement it, and deploy it within the company. The result would have the familiar software development lifecycle of a company application. The other option started with an observation about the users. Many already had enterprise ChatGPT Work, Codex, or both. The engineer could put the new workflow inside an interface those people were already using. For a team trying to shorten application deployment, the interesting question was how much of its requirement that route could satisfy.

Steffmann separated three kinds of customization. A skill is reusable Markdown that tells the model how to perform a task. It fits a difference in working method, such as the procedure an advisor wants followed during analysis. Connecting the firm’s own data introduces a tool requirement. The engineer must define what the agent can call and configure the MCP connection through which it can make those calls. A plugin packages those capabilities with the relevant skills and can be used on supported web and desktop surfaces.

A plugin extension, recently announced at DevDay, addressed a third requirement. A firm might want part of its workflow to appear differently inside the application. An extension let the developer customize parts of the interface for the use case. Steffmann’s distinction gives the engineer a concrete design question at each step. Does the advisor need better instructions? Does the analysis need an internal tool? Does the person working through it need a particular view? Each answer changes the scope of what has to be built.

16:43
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:43 · section reference included

Get into the right workspace and open the sample client package

An attendee asked what accounted for the finance product’s performance with transcripts, reports, and market data. How much came from the tools and skills, and how much from changes to the model? The question remained open while the presenters helped people get access. They supplied the workshop access code for anyone missing the full link and asked participants to confirm that it worked. The instructions were on a public website hosted with the Sites feature. Invitations to the financial workspace were arriving separately by email.

The site included a small incentive to work through the exercises. Participants who got in received 100,000 in virtual funds and could earn more by completing steps. The organizers planned to recognize the top three with bottles. Seeing people appear on the site helped the presenters tell that registration was progressing. For the finance exercise itself, the meaningful confirmation was being in the ChatGPT workspace where the participant could see the financial data and the ChatGPT for financial services plugin.

Once there, participants could follow the basic-capabilities instructions and do the setup once. A ZIP file supplied the example client data for the wealth-management case. Steffmann invited people to choose among portfolio work, research, and graphics. Each section could be tried independently. Someone interested in research could explore the financial evidence, while someone interested in charts could concentrate on how a result would be presented. The common client case kept those choices tied to the same advisor’s assignment.

The workshop page highlights “Set up once” in the sidebar. The main column shows the model and reasoning settings, how to select ChatGPT for Financial Services, and where to download the starter ZIP.Open full source frame
ChatGPT for Financial Services workshop setup

Participants interested chiefly in the financial product could stay in that part of the exercise. Those interested in development could install or open Codex on the desktop and begin its setup. The developer material would cover a skill and plugin, an MCP connection to supplement the workflow, and a plugin extension. Keeping the basic exercise available mattered. An engineer deciding what to add could first try the existing product against the sample client data and see which part of the job already worked.

20:53
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

20:53 · section reference included

Make a desktop view respond to the conversation or a file

Steffmann returned to the structure of a plugin to explain what the extension added. A plugin could contain skills, an MCP server, configuration for the tools, and interface elements for presenting the result. The extension gave the developer control over designated areas of the desktop interface. What appeared there could depend on the conversation a wealth-management user was having with ChatGPT or Codex.

An OpenAI Developers page shows a ChatGPT interface diagram with purple highlights on a sidebar item, settings, message content, the composer, and a right-hand panel.Open full source frame
Plugin Extensions in the ChatGPT interface

His concrete example was a particular file type. The developer could arrange for an extension-controlled view to appear when that type of file came up in the interaction. The user could expand it and work in an interface tailored to that material. That is a different deliverable from asking the model to produce a chart for a presentation. In one case the analyst needs an artifact to take to a meeting. In the other the analyst needs a way to interact with something while the work is underway. Steffmann described this as a design possibility. He did not identify a specific file format or show a completed client-specific extension in this passage.

26:03
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

26:03 · section reference included

Check the web, desktop, and CLI boundaries before designing a pipeline

An access question exposed a consequential constraint. At the time of the workshop, ChatGPT for financial services and its integrated financial data were accessible in the ChatGPT web interface. A company might provide both web ChatGPT and Codex, and a single employee might use both, but the workflow still had to account for which environment could reach the data. An advisor’s successful query on the web established access on that surface.

Plugins were available in ChatGPT Work and on desktop. The interface customization provided by plugin extensions was desktop-only at that point. Codex also had a command-line interface, which made it a natural candidate for a developer building a pipeline. Steffmann specifically cautioned that the CLI could not then retrieve the finance product’s integrated data. This qualified the earlier example of putting a skill on a schedule. Before reproducing a successful interactive analysis in a pipeline, the engineer needs to identify where it will execute and whether the required source is available there.

For the exercise in ChatGPT Work, participants were advised to select Astra or 6.1 Sol, open the speed setting, and choose ultrafast. They could then follow the supplied prompts for historical market data and research. The prompts gave participants a common starting point from which to inspect the product’s behavior and customize it for an advisor’s use case. By the time the presenters checked again, almost everyone had received the email and entered the intended workspace.

27:38
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

27:38 · section reference included

Give filings and market series enough context to be interpreted correctly

An attendee returned to the unanswered technical question. Beyond the model itself, had OpenAI built a financial ontology or another layer that explained why the product handled these sources better? Fabbri located much of the work in the data ontology, meaning how each source was represented for retrieval and what the model learned about the information it contained. The team changed the representation to make relevant information easier to obtain and supplied context specific to the kind of source being used.

Fabbri used a 10-K or 10-Q filing as the example. Delivering the file gets its contents into reach. Explaining what is in that kind of filing helps the model decide when to use it and what information to seek there. Fabbri said the same principle applied to integrated sources and to plugins from data-provider partners where the user had access. The useful unit was the data together with its context and a format the model could work with.

The plugin’s instructions supplied another kind of knowledge. OpenAI had worked with financial institutions over time and selected partners, including investment banks, to check product quality. Their contribution informed what counted as a realistic expert procedure. Steffmann added the scale consideration from his experience assembling financial data. Building the context layer independently means processing a large, changing collection. He described agents working across public sources and providers so the product could continue finding the right material.

A second question asked whether developers could get at the underlying structures, perhaps as a graph. Fabbri said those internals were unavailable through the product. What he could explain was the work with each supplier to understand the dataset and decide how to present it. His market-data example was the distinction between prices and returns. A price series and a return series can refer to the same security while representing different quantities. Choosing the right security still leaves room for a basic analytical error if the model mistakes one series for the other. The context should help it choose the appropriate information for the intended operation.

When an attendee suggested that special embeddings for 10-Ks and 10-Qs might explain the improvement, Fabbri rejected that explanation. He said the team had preprocessed the dataset so the model could retrieve information from it easily. He suggested thinking of the retrieval step as a tool call specialized for that dataset.

30:47
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

30:47 · section reference included

Run a supplied prompt and inspect which plugin answered it

Steffmann made the retrieval path visible in the product. Participants could copy a prompt from the workshop site and paste it into ChatGPT. In his example, the prompt indicated that ChatGPT for financial services should be used. Once it ran, icons in the interface showed that ChatGPT had picked up the finance plugin. The user could see the financial data being used and inspect the tool calls made within the plugin.

That gave participants two things to distinguish in their own runs. The prompt expressed the analyst’s intent to use the financial capability. The interface then supplied evidence of which capability had actually handled the request. Participants could inspect that behavior even though the provider-specific representations and backend remained internal. The demonstration established plugin selection and tool use. It did not supply a numerical portfolio result to reproduce.

Steffmann ended this portion at the boundary of the firm. The integrated sources could serve analysts across organizations, but an individual firm would also have datasets and tools of its own. The next engineering task would be to package those capabilities in a custom plugin. The wealth-advisor case explains why that step matters. The market source can describe a security’s movement. To connect that movement to a client outside the sample exercise, the analysis also needs the firm’s information about what the client owns.

35:31
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

35:31 · section reference included

Give the finance plugin the context to present an answer

For a wealth advisor using ChatGPT for Work, the finance product already supplies a place to interact with data, perform an analysis, and turn the result into an Excel workbook or a PowerPoint presentation. The engineering opportunity begins with what is specific to the advisor’s firm. It has its own tools, data, and logic. An engineer can make those available through a plugin that the advisor uses in the same workspace as the financial analysis.

Some of the value of the existing finance plugin is easy to miss if you look only at the number it retrieves. Consider a question about income. A table might be the appropriate answer, or the figures might lend themselves to a graph. The plugin can supply context about how to present that kind of data. With a standard model, the person building the experience would have to supply that guidance. The adapted interface is visible to the user even though the full context behind it is internal to the finance product. The speakers attributed that behavior to context supplied to the model without claiming that a separate model had been trained for the display.

Four blue bars rise from $65.59B in September 2024 to $76.44B in June 2025. Beneath the chart, a table identifies Microsoft’s FY2025 Form 10-K and Q4 earnings commentary.Open full source frame
Microsoft FY2025 quarterly revenue

The distinction matters when adding an internal tool. Giving the model access to a figure solves the retrieval problem. Telling it what an advisor normally wants to see when asking for that figure solves a different part of the job. The answer can arrive in a form the advisor can inspect immediately, before anyone asks for a finished workbook or deck.

36:52
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

36:52 · section reference included

Historical prices expose the boundary around the data service

While checking participants’ progress, the presenters mentioned that participants could also use a mobile app. Steffmann then raised a separate question about historical market prices. An advisor could request a price series within the financial service. Could an engineer retrieve the same series through an API for use in another program?

The speakers treated such an API as a desirable possibility. Market data comes with provider licenses, and the way prices can be made available in a service bears on whether they can be distributed through another interface. The ability to retrieve a series in a conversation therefore gives an engineer only part of the information needed to design an automated job. The engineer also needs to know where that job will run and what data connection it can use there.

Steffmann suggested a route for firms that already have market data in their internal systems. Build a plugin around the database the firm can access, expose the retrieval operation where the advisor works, and reuse the visualizations that make sense for those prices. He corrected his terminology as he described it. The connection to the internal data is a plugin. A further customization of how the user sees or interacts with the result can be an extension. Those are separate decisions even when the advisor experiences them as one answer.

38:54
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

38:54 · section reference included

Choose a model for the work that actually takes time

Even small requests in the workshop could take minutes. While one was running, the presenters looked for the lightning control that enabled an ultra-fast mode. They had to select the appropriate model to get to it. Steffmann described what the speed difference meant in daily use. With a slower agent, he would start a task and find several other things to do while it ran. With Ultra, it was easier to stay with the task. He also acknowledged the advantage of being able to use that mode extensively at OpenAI.

Fabbri put the demonstration in the context of customer discussions. Efficiency and cost had been prominent concerns over the previous three months. His first distinction was between unfamiliar work and a recurring assignment. For a new codebase or an open research problem, he favored Astra, the most capable model he discussed. There is value in having a model that can work out how to approach a problem whose solution the engineer cannot yet describe in detail.

A recurring report changes that calculation. Once the team knows what a good result looks like, it can put considerably more of that knowledge in a skill. Fabbri had seen Luna and 6.1 Sol produce high-quality reports and analyses with sufficiently specific instructions. The relevant comparison is how well each model performs the actual assignment with that skill. Running the strongest model on a single advisor’s report may be an easy choice. Running the report for every client makes both the per-run cost and the time it takes consequential.

He described a related division of labor in multi-agent systems. Give the more capable model the orchestrator’s job of deciding how to divide and direct the work. Some subordinate agents can use Terra or Luna. Fabbri said they had seen configurations retain roughly 95 percent of the overall result. He gave no common benchmark, price, or workload behind that figure. His condition for adopting the substitution was to build evaluations for the use case and measure whether the resulting analysis still met expectations.

Steffmann had made a similar choice while building the workshop website. He gave Astra the initial site and the more involved live room view, started the work on a Friday, and came back to it. For subsequent small changes, he used Sol because it was faster and more efficient for those edits. His advice was to revisit capability, effort level, and price as models change. The model that earns its keep on the first implementation may have little advantage on the next afternoon’s revisions.

40:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

40:35 · section reference included

Choose the surface, then prototype the connection to holdings

While participants continued the exercises, Steffmann invited observations about how they used these products and where they ran into limits. He then took up the developer’s side of the problem. A knowledge worker sees a finance product that can answer questions and make artifacts. A developer looking at the same product can inspect the structure of a plugin and ask which pieces to supply for another workflow.

The plugin structure brought together three things. Skills describe procedures the model can reuse. An MCP server exposes tools that connect it to something outside the conversation. Interface components determine what can appear as the plugin is used. ChatGPT for financial services was itself the example of a plugin. An engineer could use the same arrangement to bring a different set of procedures, tools, and views together.

Steffmann started his architecture diagram with the surface, meaning the place where the user will do the work. ChatGPT on the web, the desktop environment, and Codex running locally offer different ways to configure and reach tools. Local Codex is particularly convenient for a prototype because the developer can install a local Model Context Protocol (MCP) server and exercise it while building it.

For the wealth-management case, the sequence is concrete. Identify the source the advisor needs, such as an internal securities portfolio database or a customer database. Salesforce was another possible source. Use code and prompts in Codex to build an MCP server that can query that system. Connect locally, run Codex against the server, and try the tool. At that point the developer has a prototype with a path from a request to the firm’s data. Getting the same capability onto an advisor’s machine, under the firm’s controls, is the next piece of work.

46:24
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

46:24 · section reference included

Distribute the plugin and decide whose identity it uses

A developer can install tooling for creating a plugin and configure plugins through ChatGPT. The desktop environment also supports plugin installation. Steffmann’s enterprise example was an asset-management firm where employees receive both Codex and ChatGPT for Work. The firm could define a managed folder structure containing its plugins and distribute it through its existing software deployment mechanism. A working connection on the developer’s laptop would then have a route to the people doing the analysis.

That changes the amount of application infrastructure the team has to own. A standalone internal application requires decisions about login and access control and can take considerable time to get approved. Building in an environment the company already manages gives administrators a place to decide which employees can receive a plugin. Fabbri emphasized how often customers asked for precisely that control. If ChatGPT is where the employees will use the result, that existing administration can shorten the path from prototype to deployment.

There were still two different data paths in the diagram. The integrated financial context supplied with ChatGPT for financial services was available through the web service at the time of the workshop. It could not be called from the CLI. A developer’s plugin could separately connect to a tool that worked with the firm’s databases, using another MCP connection or another authenticated integration. In a design that needs both sources, it matters which part of the analysis will run in the service and which tools will be reachable from the chosen surface.

A three-tier diagram separates the local Codex project, MCP server and browser prototype from OpenAI-hosted ChatGPT and the firm’s systems. Arrows distinguish the tested local connection, optional integration and existing financial-source path.Open full source frame
What runs where

An audience exchange clarified how much has to go into the package. A plugin can be as small as a collection of skills. If the work requires an internal system, someone has to build the connection and manage authentication. A system-to-system connection authenticates one service to another. A connection acting on behalf of a user has to establish the identity of the person signed in to Codex. That choice determines what the integration needs in order to make a request. The employee entitled to install the plugin and the identity entitled to retrieve a particular record are both relevant.

Steffmann also pointed to the Codex sandbox and the policies that can constrain what plugin code does. For the developer, the attraction was being able to deliver code through an approved corporate mechanism and run it within an environment with controls. The firm still has to choose how to deploy that code and how its connection to the data will authenticate.

49:28
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

49:28 · section reference included

Use a skill for a method and an extension for a client view

Steffmann described writing a skill as putting reusable knowledge into a small number of Markdown files. Describe in natural language what to do, use Codex to help create the files, and share the resulting procedure with someone else doing the same work. Developers were already using skills this way in Codex. He distinguished that authoring and reuse experience from what was then directly available on the website.

A plugin gives the developer a way to deliver a larger unit. It can contain those same skills alongside executable logic, code to obtain authentication credentials, MCP connections, and user-interface components built to the plugin’s interface conventions. The folder described earlier can be packaged into an archive. A team distributing a common research method might need only the instructions. A team distributing a client lookup needs the instructions and the machinery that can actually perform the lookup.

To make the extension more tangible, Steffmann returned to a familiar ChatGPT interface. In the example, the lower left offered a place for a custom icon. Selecting it opened an experience controlled by the plugin. The icon was an entry point: the developer could also customize settings and navigation. That gives a firm somewhere to put a view that its staff would otherwise have to visit another application to see.

His example was an advisor preparing for a client meeting. The conversation already establishes what the advisor is doing. Given that context, the extension could surface a view for meeting preparation and display a particular indicator from the firm’s systems for that client profile. The advisor could inspect it and continue the conversation in the same workspace. Steffmann asked the audience to think about the employee who ordinarily has to visit five sites to get the job done. The reason to build this view is quite specific: the employee needs that internal indicator at this point in the work.

54:38
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

54:38 · section reference included

A faster model still leaves the laptop to run the code

Steffmann switched to his Codex setup and asked who already had it running locally. Quite a few participants did. He pointed out that Codex was accessible through the ChatGPT app interface and started experimenting with creating a plugin by prompt. The work took time even with Ultra. Code still had to be written and run locally, with compilation where needed. The example became a discussion of where the agent’s work executes while the room waited.

The workshop’s “Build a plugin” page shows a copyable Codex prompt with the reference skill, plugin manifest path, version and required advisor brief format.Open full source frame
Package Advisor Review

On a desktop, Steffmann could open other chats, work on another project, or start building a second plugin. All those tasks still had a machine on which to execute. His example from financial services was an application-security check against a large repository. A sufficiently large scan could tie up his computer. Increasing the model’s output speed does little for the portion of the job that spends its time running code on the laptop.

For that workload, he wanted a company environment to which he could hand off the calculation and get the result when it finished. The point applies to several concurrent tasks as well as to one large scan. The interface can remain the place where the employee initiates and follows the job while the compute runs remotely. The passage describes that deployment choice and the local bottleneck that motivated it. The plugin experiment itself was still running when the discussion moved on.

59:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

59:00 · section reference included

Put examples of finished work beside the instructions

Asked about reuse, Fabbri described an internal marketplace where teams share plugins and skills. A shared package can contain files as well as instructions. An artifact template might be a website, a PowerPoint presentation, or an Excel workbook. For research delivered to private wealth-management clients, the team can supply several historical examples and instruct the skill to use them as references. An advisor asking for the next report then has access to the same examples as the colleague who developed the procedure.

Fabbri proposed a simple exercise. Take a spreadsheet, presentation, or PDF whose format matters to the team. Supply a fresh analysis and ask the model to put it into that format. Inspect the result against the original. This tests two requirements at once: whether the model can produce the requested artifact and whether it understands the conventions embodied in a real piece of the firm’s work. For a spreadsheet delivered to an investment-banking audience, the quality of the formatting is part of whether the artifact is usable.

A chat request for a five-slide Project Atlas overview sits beside the resulting presentation. Its financial profile page charts revenue, operating margin, and free cash flow.Open full source frame
Turn the analysis into client materials in firm style

Fabbri said the team had seen considerable improvement in spreadsheet creation and formatting over the previous six months. He mentioned internal benchmarks but gave no scores. The test he offered participants was one they could perform with their own material. If the result contains an inaccuracy, identify it precisely and revise the skill so the next run has that instruction. Editing the delivered spreadsheet helps one recipient. Putting the correction into the shared skill gives the rest of the team a chance to benefit from it.

Sharing also raises the question of what happens at the next model update. Within a model family, Fabbri had generally found skills reusable across incremental updates with relatively little refinement. He expected a larger transition, such as moving from a fifth generation to a sixth roughly a year later, to require adjustments. The examples do double duty here. They communicate the desired format to the model and give the team something concrete against which to inspect a new model’s output.

1:02:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:02:58 · section reference included

Keep portfolio analysis small enough for a team to share

Steffmann had seen customers create skills so enthusiastically that teammates struggled to find and maintain them. Two front-office colleagues or quants may perform much the same task with a few differences. If each records the whole workflow as a personal skill, the team acquires several descriptions of its common method. Someone trying to improve the method first has to discover which descriptions exist and decide where the change belongs.

His advice to one customer was to remove some skills and define the capabilities the team actually shared. Portfolio analysis and trading analysis were his examples of a useful scope. Each names a recognizable piece of work that can be reused in several workflows. A single skill covering everything an advisor does makes even a small variation harder to maintain. For an application developer who needs control over deployment, Steffmann leaned toward packaging the solution as a plugin. For someone who wants to specify how a well-defined task is performed, the skill is still the unit worth getting right.

Steffmann added a qualification to the discussion of model upgrades. Teams still need to retest the models on the work that matters to their business. He described customers with early access to pre-production models using that access to identify problems before release. His concern was as much organizational as technical. Someone needs to decide what a skill encapsulates, which version colleagues should use, and whether it still produces the expected work after a change.

1:06:10
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:06:10 · section reference included

Let a disagreement in the research trigger the next agent

Fabbri’s team had focused primarily on applications built against the API. In the months he had been at OpenAI, he had seen work that once required a separate codebase and API keys become feasible as a plugin. His example came from an internal case study in advanced financial research. It went beyond the advisor’s recurring report to a question where the investigation itself determines what needs to happen next.

In the original API application, a planner received the financial question and broke it into subquestions. For each one, it created a separate subagent to conduct independent research. A critic then gathered the findings, combined them, and checked whether the conclusions conflicted. This is a more demanding job than concatenating several answers into one report. Each investigation may appear satisfactory on its own while leaving the combined account internally inconsistent.

When the critic found a contradiction, it dispatched a new subagent to investigate that particular discrepancy. A further pass therefore had a defined purpose. The process continued toward a report that met the required quality and addressed all the original questions. Coverage and consistency are separate tests here. Several agents can agree while overlooking one of the planner’s questions, or they can cover every question and still produce incompatible findings.

Fabbri said Dom had recreated the research workflow as a Codex plugin. The analyst could stay in Codex and see which subquestions the agents were investigating as the work progressed. A developer could also build a dedicated view to help the analyst follow those investigations through to the assembled report.

1:08:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:08:33 · section reference included

Rebuild equity research around the tools Codex can already call

The author of the equity-research application then explained the move from the implementation side. The original standalone application handled professional stock research through parallel investigations and checks. It needed considerable orchestration because its workflow mixed deterministic operations with decisions made by language models. Some steps had a prescribed next action. At other points, what the system had just learned determined which tool or research task it needed next.

Users were already consolidating this work in Codex or ChatGPT. That made a separate application harder to justify and suggested a specific engineering question: how much of the old orchestration could Codex take on? It already had subagents, could direct a changing set of agent tasks, and could connect plugins and data sources. A research plugin could draw on those capabilities without requiring the application author to build a custom connection for each part.

The author used the term “distributed tool calling” for the way the research could call the tools appropriate to the investigation as it developed. He credited it with faster, more accurate tool use, without offering a timed comparison or accuracy score. The resulting design could still keep parts of the workflow rigid where particular filters were required and leave others flexible enough for the model to choose its next action. At the end of this passage, he was tracing those choices back to the manually configured application, which had used language models at some nodes and traditional deterministic processing at others.

1:12:03
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:12:03 · section reference included

Let the researcher change the sources and the quality checks

A researcher who uses a separate research site has to leave their working environment and accept the choices its builders made. Bringing that process into Codex gives the researcher two concrete things to change. They can specify the data sources they want the research to draw on, and they can specify the checks a result should pass. Someone who knows the subject can adapt the next run while working on the analysis. They can also see enough of the procedure to decide which part needs revising.

How does a process developed this way become something a whole team can run? The presenters distinguish the desktop application from the Codex harness, the engine that runs the agent and its tools. The desktop provides a managed product in which a business technologist, quant or researcher can put together a workflow quickly. Plugins give that workflow a way to connect to systems the organization already uses. A developer can then use the Codex SDK to run the harness programmatically on a server. App Engine is one hosting example the presenters mention.

Those choices let the team defer a consequential interface decision. The researcher can work out which sources and checks produce a useful answer before an engineer builds a dedicated front end. If the team eventually wants a server-side program behind its own interface, the engineer can reuse the work that went into the research process. For a deployment that calls for closer inspection or customization, the application is proprietary, but the underlying runner is open source. An enterprise can examine the code that executes the workflow and choose runner settings appropriate to its own interface.

1:13:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:13:42 · section reference included

How the harness handles delegation and a long research context

Fabbri gave a reason to use the Codex harness even when a developer could assemble the tools independently. OpenAI uses its own tools during model post-training, and he attributed some of the models’ performance in Codex to familiarity with that environment. Delegation was one example. The agent could decide during a task whether to start a subagent. Fabbri said the Ultra setting encouraged it to delegate more often, which mattered for research with several independent lines of inquiry. The earlier ultrafast control governed how quickly the model generated tokens.

A second mechanism deals with the material those investigations accumulate. A secondary model compacts the current conversation in the background, removing redundancy to keep the working context within bounds. This matters in research because an early instruction can still govern the work hours later, after the agent has written code and produced intermediate results. The team says compaction let it undertake research tasks that would otherwise have needed much more context. Compaction is also available through the API. With the Codex harness, the developer gets that behavior as part of the runner.

A presenter who had worked as a quantitative researcher describes a test using a quantitative finance paper on Brownian motion and options pricing. He asked a model he identifies as version 5.5 to reconstruct the codebase from the paper, generate a numerical result and see whether it agreed with the published one. That last instruction matters. Producing plausible simulation code was only one step. The agent also had to run the calculation and carry the paper’s original claim far enough through the process to make a comparison.

About two hours later, he says, the agent had recreated a substantial quantitative codebase, including the stochastic simulation and model calibration. He credits compaction with making a run of that length practical. The evidence he gives is the scope of the reconstruction and the elapsed time. He supplies neither the paper’s numerical value nor the model’s value, so the degree of agreement between them remains open. For someone reproducing the exercise, the comparison with the paper is a distinct deliverable beyond the working implementation.

1:17:11
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:17:11 · section reference included

A plugin extension brings a custom interface into the desktop

While the discussion continues, a presenter has Codex working in parallel on a plugin extension. He points to the right side of the interface to show where a custom view can connect to the existing product. The example is deliberately small. What the audience can observe is the place an extension occupies in the workspace and that a prompt has set its construction in motion. The presenter refers to Figma and Adobe as partners that have built more complex applications. His broader prediction is that software providers will increasingly distribute applications through AI platforms, and enterprises will develop their own internal equivalents.

The filter lists Jordan, Alex and Priya. Jordan is selected, slow responses are enabled, and the expanded local JSON preview lists six unresolved items. Codex reports that all 21 tests pass.Open full source frame
Needs client information filter and Jordan’s bounded context preview

Why would a technical user want that interface? One presenter recalls joining OpenAI when many engineers around him still worked in the Codex CLI. He had since seen more of those users spend their time in the native application. His own example comes from quantitative experiments. He used to keep a Jupyter notebook open alongside his other tools. He can now do that notebook work within Codex. The desktop has value for him before he distributes anything to a colleague, because the place where he conducts an experiment can also hold its working materials.

The prospective audience for a plugin is wider. A developer can give a colleague who understands finance, but has little reason to use a CLI, access to a procedure and the tools it needs. Enterprise distribution controls provide a route to those users. The presenters suggest that teams can deliver useful tools in weeks rather than months. Finance makes an attractive test because an analysis often combines changing data sources, technical work and a finished artifact. They invoke claims of tenfold or hundredfold productivity gains in engineering as an ambition for knowledge work. They offer no corresponding measurement for the finance workflow.

1:20:43
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:20:43 · section reference included

What carries over to cybersecurity, and what structured data leaves unsolved

An audience member asks whether finance is especially amenable to this approach because its data is structured. Are the presenters building an ontology over that data, and is there a parallel effort in healthcare? The first response identifies healthcare as a priority, including for research, then develops a more concrete comparison in cybersecurity. There, the team wants a security specialist to be able to start using a model on a familiar problem without first having to become an AI specialist.

The example combines a specialized cybersecurity offering called Daybreak, tools the practitioner can use, and a plugin for static asset scanning tuned to the model. The team also has a library of skills covering stages from scanning through final review and correction. Each piece supplies something different. The model works on the problem, the tools let it perform operations, and the plugin and skills give the security team an initial procedure. The team can start from a scan it knows how to assess and follow the findings through review. Healthcare is named as a field of interest, but the presenters give this implementation detail for cybersecurity.

The other response returns to the audience member’s point about an ontology. Structured data is attractive, but an enterprise may have many structured stores that evolved in isolation. Each holds usable records, yet the context needed to use them together can be missing. One strategy is to design a context layer across every store before making the data available to an agent. The presenter’s objection is the time that takes in a company with a substantial legacy estate.

He proposes starting with teams and the work they already do. Give a team a working environment in ChatGPT and Codex, connect the sources its workflow requires, and build up the necessary context as those connections are made. Other teams and sources can follow as the organization modernizes its data architecture. He draws a distinction from his experience inside OpenAI, where he says much of that context already exists and the company has less legacy infrastructure. An established firm has to budget for discovering how its stores fit together, even when each one is well structured.

1:24:23
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:24:23 · section reference included

Set the extension’s filesystem, network and approval boundaries

Installing an extension can cause code to execute on someone else’s desktop. That changes the deployment question considerably. A developer may know exactly why a prototype calls a particular service from their own machine. Once colleagues install it, the security team needs to know which destinations it can contact, what it can read locally and who can use it. A tool call that needs one URL gives the presenters a concrete example. The organization can restrict where that call goes while still allowing the operation that made the extension useful.

They describe several layers of control. Corporate network security and endpoint inspection still apply. Inside Codex, an enterprise administrator can deploy configuration policies in TOML files. Those policies can constrain actions to a workspace, determine what the client can access locally, restrict networks or individual URLs, and control which people can use particular plugins. The administrator can set different policies for different teams and distribute the settings during rollout. Code executing inside the client is then subject to the configured sandbox.

Consider a team developing a plugin in its project workspace. It needs room to run tools and operate on the project’s files. The same workstation may contain sensitive folders belonging to another project. A workspace boundary lets the administrator express which files are in scope. A network rule addresses a different question, such as whether that plugin may contact a particular site. Plugin policy addresses a third, namely who may use the integration at all. The presenters also put a limit on what those controls accomplish. Whoever operates the underlying tool still has to protect it.

Approval prompts introduce a tradeoff the end user feels directly. A security team wants scrutiny for sensitive operations. A business user who has to click through a prompt for each ordinary visit to an expected site experiences the tool as slow. The presenters describe configuring which actions can proceed and which require a decision, taking account of the data, destination and working folder. Builders need to explain that behavior to the people receiving a plugin. In the large institutions the team works with, approval and permission settings are usually among the first deployment discussions.

1:28:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:28:33 · section reference included

From a workshop extension to an internal or public plugin

The presenters pause for a workshop interlude and invite three participants to introduce themselves, with OpenAI water bottles for the recipients. Cohen is a data engineer at the Dutch branch of Xebia Data, a consultancy. He had attended AI Engineer in London and wanted to see what people in New York were doing in finance. Matt describes building an AI-oriented family office at X1 Wealth and using Codex extensively. Zach, founder of The Clockworks, describes making applications that use AI to investigate things he previously could not, with much of his attention on development.

The suggested homework is to build a plugin extension and distribute it. The presenters distinguish two audiences for that exercise. A public marketplace offers a software provider a channel to external customers. Applying takes some work because the extension can affect people outside its maker’s organization. The discussion mentions checking that it works reliably and safely and belongs in the right category. A company can also distribute an extension internally using the same general idea. A developer whose intended users are colleagues can serve that audience through the corporate system.

The analogy one presenter reaches for is the App Store. An emerging marketplace might change how a software provider reaches customers, much as app stores did. He presents that as a reason for developers to pay attention to distribution. The exercise itself is smaller and more testable. The builder has to turn something that ran in their workspace into something another person can receive and use.

1:32:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:32:35 · section reference included

Use evaluations to find where a production agent fails

The applied AI team also works with customers on custom API applications, where an engineer takes on more of the system design. A recurring part of that work is developing an evaluation for a particular problem. A person can read an answer in an individual chat and decide whether it helped. A team deploying an agent repeatedly needs a way to establish how well the product performs across cases. Without that, a claim that the agent increases productivity gives the team little help deciding whether it is ready for production.

The team starts from an evaluation dataset and investigates cases where performance falls short. Several explanations are possible. The prompt may communicate the task poorly. The system may communicate poorly with a tool. The model may also reach a genuine limit and behave unexpectedly even under favorable conditions. Those explanations lead to different work. Engineers can revise instructions or the tool interaction and rerun the case. A reproducible failure that persists in a well-specified environment gives the applied team something concrete to take to model researchers for a future iteration.

An audience member asks how mature companies are at this, from understanding evaluation fundamentals to evaluating automated research. The former quantitative researcher answering considers evaluation one of the largest obstacles, chiefly because two kinds of expertise have to meet. Subject-matter experts know what counts as a consequential mistake in the business. Engineers build the dataset and the tests. Getting both groups to define and implement a useful check can be harder than getting the agent to produce an initial answer.

He gives 70 percent as an example of a score that, on its own, offers little direction. A team needs to inspect the underlying metrics to see which behaviors are strong and which are failing. Applied to his earlier paper-reproduction example, reconstructing the simulation, running the calibration and matching the published quantity are distinguishable outcomes. An implementation could accomplish the first two and miss the third. Keeping those results visible would tell the investigator more than a single rating for the finished response.

1:36:44
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:36:44 · section reference included

Start with simple checks and give a model judge a binary question

The evaluation advice has an order. Start with simple checks whose behavior the team understands. Add complexity once it can interpret the results. Beginning with an LLM as judge introduces two uncertain systems at once. When a run gets a poor score, the engineer has to work out whether the agent performed badly or the judge failed to recognize a good result. A simple initial test gives the team a reference point before it makes the evaluation itself depend on model judgment.

When a model judge is warranted, the presenter recommends decomposing a one-to-five rating into individual true-or-false questions. Each question should ask for a yes or a no. In the paper example, an evaluator could ask whether the result includes a numerical comparison with the paper. That is a narrower judgment than rating the entire reconstruction, and a reviewer can inspect the answer that led to it. Separate questions can capture other requirements without asking the judge to decide how much each one contributes to an overall grade.

The presenter mentions the Decision API as one possible implementation of this pattern. He describes it as returning a fast binary decision together with a probability or indication of confidence. The attraction for evaluation is the fit between the interface and the question. An engineer can ask about a specific condition and retain the decision for that condition. Choosing conditions that actually matter to the business still takes the subject-matter work he has just described.

1:40:37
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:40:37 · section reference included

Give automated research a target it can iterate against

The second half of the audience question concerns automated research. The presenter connects recent gains in mathematics with earlier gains in programming. Quantitative work often needs both. Reproducing a paper requires understanding the mathematical procedure well enough to implement it, then using the implementation to test a scientific claim. He suggests reproduction as an entry point because papers offer tasks at different levels of difficulty and, in cases such as the pricing example, an external result against which to compare the output.

For an iterative problem, he describes Codex goal mode. The user specifies an objective, preferably a numerical one when the problem admits it. His example uses an existing agent, an evaluation dataset and a benchmark. Ask Codex to adjust the agent’s prompt to maximize measured performance. Codex can consider a change, try it, evaluate the result against the target, and keep exploring new ideas and hypotheses. This is what he means by hill climbing. The benchmark gives successive attempts a common measure and supplies a reason to keep or reconsider a change.

That example also explains why the preceding evaluation discussion matters. If a benchmark compresses several requirements into a score the team barely understands, the system can pursue that number while the team learns little about which capability improved. With individual checks available, the researcher has a way to examine the effect of a prompt change. The presenter calls prompt calibration a simple instance of automated research. The same general instruction to pursue a goal can support a much less prescribed investigation.

He points to mathematical results for which the team used goal mode and says that, in one case, it published the prompt. In describing the task he corrects himself from a theorem to a conjecture. The prompt is of interest because it shows how the research objective was put to Codex. For a research run in ultra mode, he describes the agent dispatching subagents to investigate independent avenues in parallel, combining their findings and iterating. Goal mode specifies what to pursue. Ultra influences how readily the agent recruits help pursuing it.

A colleague endorses the shift in emphasis. In his experience, six months earlier a builder had to spend more time engineering prompts and organizing the agents’ work by hand. A more capable system can take on some of those choices, which leaves the builder with the demanding job of saying what outcome matters. The finance team invites customers to bring specific cases and evaluation problems back through their account contacts. A goal that succeeds in a demonstration still has to hold up against the work the firm actually needs to do.

1:41:45
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:41:45 · section reference included

Write back through a tool to the system that owns the record

The final audience question picks up a conspicuous feature of the examples. Many skills and plugins read information. Can an agent also write the result back to the system a team works in, such as its accounting system? Dom, the colleague invited to answer, starts by separating orchestration from storage. Codex can coordinate a plugin extension while its tools interact with other systems and store data remotely. The first design decision is where the result needs to exist after the user finishes working on it.

The simplest destination is the project’s local filesystem. A tool can return output in a specified form, and skill instructions can tell Codex how to process it and where in the project to write it. During extended work, the filesystem gives the agent a place to retain intermediate material and return to it. This complements conversation compaction. The harness can manage the size of the conversation while a file holds an output the project still needs. For an individual working locally, that file may itself be the desired result.

For a workflow shared with another application, an extension can use a tool that contacts a central server or connects to a particular database. Dom describes a proxy-voting implementation concerned with what the voting systems had received and where material had been sent. The user worked in Codex. An application server connected through the plugin extension owned the record. The write operation had concrete contents: the report, its findings, the date and the sources. The tool wrote those back to the database that powered a production application outside Codex.

That placement served two audiences. The operator could conduct the work in Codex, while administrators and people responsible for legal verification could use the firm’s existing system of record. Dom describes connecting particular tools through MCP, the Model Context Protocol, and assigning the permissions appropriate to those connections. A builder can keep a project local or expose a path to the service that needs the result. In the proxy-voting case, saving the finished report only in the operator’s workspace would have left the production application without the record it needed.

A second presenter adds one more output for audit-sensitive work. Alongside the artifact, the team often retains standardized logs that let a technical reviewer trace actions and decisions to the data sources and logic behind them. A report gives the reviewer the findings. The log lets that person examine how the workflow reached a particular finding and which action followed. For the financial processes the team describes, retaining that history is part of the plugin’s work when it creates the artifact.

1:46:41
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:46:41 · section reference included

Transcript download
Full transcript

Loading transcript…