You can now add files to a chat. Many estates live in exports and slide decks rather than in one system, so the agent reads those too: choose the paperclip in the composer, add up to five files to a message, and ask your question.

A spreadsheet becomes data the agent works with like a connected source: it searches, filters and totals the rows in place, and a Decision brief can verify its values against them. A document is read page by page, searched, and quoted, and a brief verifies the quotes. A picture goes to a model that reads images; if your chat model doesn't, pick a picture-reading model next to the chat model under Settings → Models and Studio passes it a reading of each picture.

Every answer the agent gives from your sources now carries a Source check. Studio looks for each figure in the answer in the records and documents the chat's tools returned, and counts the records the answer cites against the ones it read. Everyone in the chat sees the same line.

Open it to see each figure in the answer's own words, and where Studio found that value: the system, the field and the record, or the document and its page. Figures Studio could not find are listed too, with a note that they are often numbers the agent worked out itself, so you know what to check before you take the answer into a meeting.

Until now the agent read an estate one record at a time, with every record passing through the conversation. It now reads a whole list in one pass, keeps it to hand, and searches, filters and totals it in place. Runs on large estates are faster and cost a fraction of what they did.

It follows references between records instead of guessing joins, links the same application across two systems by rule, and writes a short note on what each connected system's data means. Those notes, and the way it learned to read each source, are kept for your organization, so later chats start where the earlier ones left off. A list shows how old it is, and the agent can refresh it from the source.

Every Library template now runs a method your architecture board already knows, with the steps named the way practitioners name them: Scope Definition, TIME Assessment, Gap Analysis, Compliance Assessment, Risk Classification. Each one rates in your EA repository's own words and decides in its discipline's vocabulary, and every view it draws is specified in the template: the capability map with its levels and heat views, the roadmap's lanes and milestones, and the impact graph with its conflict and propagation rules.

A template also names the sources it reads by type, such as an EA repository or IT service management, and the data each must provide, down to the fields: applications with their owners, lifecycle and cost, say. It never names a product, so the same template runs on whichever systems you have. Once the workbench exists, Settings → Connections asks you to link each source to one of your connections, listing the ones that fit first; a stage that reads a source you haven't linked waits and says which one to connect.

The room a workbench opens in has been redrawn around the stage you are on. The cycle's stages run down the left, each with who does it and a status pill: Not started, Running, At the gate, or Passed. The current stage fills the middle, with one tab row: its Outputs, the Visuals it drew, the Chat with the agent, the Session log, and its Contract, which says what the stage may read, write and call.

Every message you send acts on the current stage, and the agent's answers appear in the canvas beside the stage's output rather than in a separate pane. The workbench's Settings are now three tabs: Connections, for the servers and tools its runs may use; Access, for who passed each gate this cycle; and Audit, its history.

When the agent hands a slice of work to a sub-agent, you no longer wait for the hand-off to return. A line under the delegation in your chat shows what the sub-agent is doing now, the system it is reading, how many steps it has taken and how long it has been running, and then how it ended. Open shows its full chat at any point.

Sub-agents also run as long as the work needs. There is no fixed time limit on a delegation any more, so a large read or a long trace finishes instead of being cut short.

We're introducing Decision briefs. A Decision brief is the page a forum decides from: one question, the options, the trade-offs, a recommendation, and the evidence behind it. The agent writes it from the analysis in the chat and opens it on the Stage, where you and the agent edit it together.

Studio checks the evidence, not the agent. Every value a brief cites is matched against what your connected sources returned in that chat, and each piece of evidence is named after the system it came from and marked Verified, Mismatch, or Unverified. The recommendation can only rest on evidence Studio confirmed.

When the brief is ready, send it to review: name the approvers and the rule — all of them, any one, or a number of them. Approvers sign or record a dissent against the version they read. Later, reopen a decided brief and its evidence is read again from the sources, so you can see what moved since the call was made.

We're introducing Cascade Impact from AI Transform Studio Visual MCP Apps.

Cascade Impact traces a retirement, a platform move, or a merger cut across what else sits in its path, so you see the blast radius before anyone commits. The graph explains itself as you read it:

Long work now carries on while you are away, and tells you what happened when you come back.

If a run is interrupted by a restart, it picks up again from where it left off. A banner above the composer says whether the run is still going, waiting for your answer, paused, or how it ended, and the Runs menu lists the chat's earlier runs.

Run emails say how a run ended — finished, blocked, or out of rounds — and each member chooses whether to get them under Organization settings → Notifications.

Admins decide whether agents may keep writing in turns nobody is watching. With Allow unattended writes off, every change to source data waits for a person. Research keeps moving: one web search approval covers the rest of an unattended run.

We're introducing decision models in AI Transform Studio. A decision model answers the question you define — a score, a yes or no, or one option from a set — and returns a confidence with every answer, rather than writing prose.

We're starting with Jev, TypeSafe's decision model, and introducing it for Assessments. You set the criteria and the decision, choose the records in scope, and Jev judges each one. Anything under its confidence floor is refused with its reason, never guessed, and a rule in your standard can escalate a record to a person.

The result shows every record at a glance: how many settled, how many were refused, and how many were escalated. Open a record to see its assessment card — each criterion's answer and confidence against the floor, and the decision it concludes with.

We're introducing Landscape from AI Transform Studio Visual MCP Apps.

The agent builds a nested map of the estate from the sources you connected — business capability maps and application landscapes. You can colour by a view, and reopen that map later with the sources still attached.

We're adding OAuth so you can sign in as a user to a MCP server. The add-server flow now supports that sign-in, including servers that need an organization app rather than a public link.

Once you sign in, the agent can use that server in the session.

Four templates for work that usually lives in a register, a policy pack, a board paper and a journey slide that never meets the systems behind it.

The forums that take in demand, fund it and approve its design rarely share a picture. These three templates write the record each one decides from.

Tolerate, invest, migrate or eliminate is a decision, not a grid in a spreadsheet. These templates walk one slice of the estate at a time.

Principles that cannot be applied in a forum next Tuesday are not principles. These two templates keep the principles sharp and the exceptions to them honest.

A strategy needs two pictures the executive team can steer by: where the money should go across the capability map, and how one domain gets from today to its target. Two templates for that work.

We're introducing Factory. Factory is how you create a workbench: you describe the repeating job, approve the plan, and Factory writes the folder tree you then run.

We're also releasing a library of workbench templates. On day one, two templates for deal work:

We're introducing Workbenches. A workbench is a folder tree for a transformation job: numbered stages, each a folder with its own brief — what it reads, what it writes, and what you check.

The tree is the job. Status lives in those folders, so you can open any stage and see where the work stands. The agent works one folder at a time, and a gate sits between stages — the next folder does not open until you have reviewed that stage. That is how a repeating transformation job stays structured, instead of one long thread.

We're introducing Goals on the session. A goal is for long-running work: you set the objective once, and it stays on the session while the agent works through it.

The agent can keep that objective in view across turns, the same way a coding agent holds the job it is working on. You can edit or clear the goal when the work changes.

We're introducing sub-agents so the main session can hand a slice of work to another agent. There are two modes.

One carries this session: the child starts with the conversation so far, which is useful when the slice depends on what you already covered. The other starts fresh: a self-contained prompt and no parent history, so that slice has its own context.

The child reports back with a result. You stay on the main thread.

We're introducing Plan mode. Before the agent starts the work, it writes a plan and waits for you to review it.

You can approve the plan, change it, or send it back. Nothing runs against your connected systems until you say so. This is the same idea as planning a change in a coding agent before it edits the repo: agree the approach, then run it.

When the agent needs a decision from you — which source to use, whether to take the next step — the session holds and shows that wait in chat.

You answer, and the run continues from the same place.

We're introducing Tasks in chat. Tasks are a checklist the agent keeps on the session and checks off as it progresses through the work.

Each item shows whether it is done, in progress, or still open. If you reopen the chat later, the list is still there in the transcript, so you can see how far the work has got.

We're introducing present mode. It opens the artifact full-screen from the Stage: the same board, the same connected data, without the rest of Studio around it.

Some actions need a person before they run: a write, a sensitive tool, a step you have not seen yet.

We're introducing approvals in the session. You see what is about to happen, then allow it or hold it. The rest of the session can continue while that gate is open.

We're introducing Roadmap from AI Transform Studio Visual MCP Apps.

The agent assembles the work from the sources you connected, on a timeline. You can rework dates while you are still deciding.

We're introducing Kanban from AI Transform Studio Visual MCP Apps.

The agent builds the board from the data sources you connected. You can move a card, ask the agent to re-sequence, and the board updates. You can reopen that board later with the sources still attached.

We're introducing a catalog of MCP servers you can connect in Studio. Pick one from the list, or add a custom server by URL and keep it as a profile on the session.

Once you connect it, the agent can use that server's tools in the session. The catalog is a starting set — we'll keep adding supported servers. You choose what the session can reach. Studio does not replace those systems.

We're launching AI Transform Studio, an agentic workspace for enterprise transformation work.

You and an agent work the same question against the systems you already run, and leave with a living artifact you can reopen. Bring the AI models your organization already uses.