What you will take away from this lesson
Article 304 wrapped assets into collections. This article is about what happens when the assets themselves need to change: a number was revised after the close, a chart should show one more region, a sentence in the report came out wrong. The right move is to edit the existing asset, not generate a new one. The recipient's link keeps working, the history stays on a single asset, and any collection that references it picks up the change automatically.
Most of those changes are small, and small changes have their own move: name the part you want changed and let the agent edit that part. “Make the revenue chart green” or “fix the heading typo” is enough. The agent does not rebuild the document around your correction, which is why the change is fast, cheap, and provably confined to what you asked about. That is the first half of this lesson.
The second half is what all of it does to the record. Manage Asset (manage_asset) covers targeted edits, whole-body replacement with action=update, list_versions to read history, and revert to roll back. All of them are owner-only on the agent path. Editor-share recipients can update content from the portal, which is covered in passing at the end.
Learning Objectives
- 01Make a small change by naming the part you want changed, so the agent edits that piece and leaves the rest of the document alone.
- 02Ask the agent what is in a report, so a phrase like "the second chart" becomes something it can act on.
- 03Compare two versions to see what a change did, without reading both.
- 04Edit an existing asset in place instead of generating a new one, so the link your boss has keeps working and the audit trail stays on the same asset.
- 05Tell the difference between a content edit and a metadata edit, because only one of them creates a new version (and one of them is what you reach for when you fixed a typo in the name).
- 06Read an asset version history and pick the right version number to revert to.
- 07Recognize that revert is append-only: it creates a new version with old content, it does not erase newer ones.
- 08Know who can edit what: owner via the agent and the portal, editor-share recipients via the portal only.
Where this lesson sits in the curriculum
304 wrapped multiple assets into collections. 305 zooms back in on a single asset and walks through what happens when the content needs to change after the first save.
300 Series: getting more out of Plexara
- 301Creating reports and dashboardsHow to ask the agent for shareable work product instead of chat that scrolls away. What happens when you save, and the habits that decide whether your dashboard survives next week.
- 302Exporting dataWhen you need a spreadsheet a teammate can sort, or a data file for another system, instead of a view.
- 303Sharing your workName a teammate and they get mail with your note in it and a link straight to the work. Name somebody with no Plexara account and they can still read it. Or mint a link for an audience, with an expiration and an access mode you pick.
- 304Creating collectionsBundle a dashboard, a summary, and the underlying data into one navigable briefing. Build it during the session via the agent, or by hand on the portal's Collections page.
- 305Editing what you already haveName the part you want changed and the agent edits that piece in place. Ask what is in a report, compare two versions, and keep shared links working. Metadata edits do not bump the version; content edits do; revert is append-only.
- 306How an asset was builtThe audit trail Plexara records at the MCP boundary: which tool calls the agent invoked, with what parameters, in the producing session. Captured at save time, readable by you or the agent.
- 307Turning a comment into something the agent remembersA reviewer opens a correction on your dashboard, an agent folds it into the knowledge loop with memory_capture thread_ids, and the person who raised it confirms or disputes the resolution. Worklists keep the open ones visible; manage_feedback works the whole backlog in one pass.
- 308Reproducible promptsSave the starting instruction as a first-class prompt with named arguments via Manage Prompts (manage_prompt). Re-run it later with different values. Personal, persona, or global scope. What re-running does and does not guarantee.
The 300 series is practical recipes for working with Plexara day to day. It assumes the mental model from 205.
Why edit instead of generating a new asset
It is tempting, especially during a fast-moving analysis, to ask the agent to redo a dashboard with the new numbers and treat the result as a new asset. That works for one-off cases. For anything you have already shared, or anything that lives inside a collection, in-place editing is the right move. Three concrete reasons make the difference.
Why editing in place beats re-saving as new
Shared links keep working
The portal URL points at the asset_id, which never changes. Update content and the next view returns the new body at the same URL. Your boss does not get a "this link no longer works" email when you fix the chart.
History stays on one asset
Versions stack on the same asset. When someone asks where a number came from six weeks later, the audit trail is one list_versions call away. Re-saving as a new asset scatters the history across two records that nobody knows are related.
Collections pick up the change
A collection item is an asset_id reference, not a copy. Edit the underlying asset and every collection that includes it shows the updated content next time it is opened. Re-saving as a new asset leaves the old reference pointing at stale content.
Name the part you want changed
Most corrections are small: one chart is the wrong color, one figure was restated, one heading has a typo. For those, ask for the change itself rather than for the document. The agent finds the part you named and edits it there, which is why a one-line fix to a fifty-page report costs about what a one-line fix should cost, and why the fifty pages you did not mention come out the other side unchanged. This is the default move for editing in Plexara; replacing a whole body is what you reach for when the whole body is genuinely what changed.
Three moves for changing part of a document
Ask for the one change you want
Name the part, not the document. "Make the revenue chart green." "Fix the typo in the Methodology heading." The agent edits that part of the report in place instead of regenerating the document, so everything you did not ask about is provably unchanged, and the change costs what the change is worth rather than what the whole report is worth.
"In the Q3 board report, recolor the revenue chart from blue to green. Leave the rest of the report alone."
Ask what is in it when your description is loose
The agent can list what a report contains: its headings, and on a dashboard the individual panels and charts with their sizes. That listing is what turns "the second chart" or "the section about refunds" into a specific thing it can act on. Reach for it when your description could match more than one thing, or when you are editing a document someone else built.
"List the sections and charts in the Q3 board report, then update the one showing Southwest revenue."
Compare two versions instead of reading both
When you want to know what a change actually did, ask for the difference between two versions. You get back the parts that changed, which is a far shorter read than the two documents it came from, and it is how you check a correction landed the way you meant it to.
"Show me what changed between version 4 and version 5 of the Q3 board report."
Naming a part works on the documents that have parts: HTML reports, interactive dashboards, SVG diagrams, and markdown reports, where the part is a heading. A CSV or a JSON file has no named parts, so on those you quote the text you want replaced instead. Whichever route you take, the result is an ordinary new version, so everything the rest of this lesson says about history and revert still applies.
Three kinds of change
There is one Manage Asset (manage_asset) action called update, a targeted-edit action alongside it, and a related action called revert. Between them they cover three operationally distinct kinds of change: a metadata edit, a content edit, and a rollback. The difference matters because only two of them create a new version, and the audit trail is easier to read when you know which is which. Where a targeted edit lands is the first question people ask, and the answer is that it is a content edit like any other.
Three kinds of change, with whether each one bumps current_version
Metadata: name, description, tags
Bumps current_version: No
Renaming an asset, rewriting the description, adding or replacing tags. None of these touch the content body in S3, and none of them create a new version. The asset record updates in place.
"Rename the Q3 2025 sales review asset to Q3 2025 regional sales review and add the tag southwest."
Content: the asset body itself
Bumps current_version: Yes
Both routes count here: recoloring one chart by naming it, and replacing a whole dashboard with a rebuilt one. Either way the new content lands in S3 under a fresh version key, current_version bumps, and older versions are preserved. A targeted edit is not a lesser kind of change to the record; it is the same kind, described more precisely.
"Update the Q3 2025 regional sales review with the corrected Southwest figures and a new YoY tab."
Revert: roll back to an earlier version
Bumps current_version: Yes
You decide a recent change was wrong and want the previous content back. Revert reads an older version's content and writes it as a new version. The old "wrong" version is preserved in the history; you have not erased it.
"List versions of the Q3 regional sales review. Revert it to version 3."
The metadata-vs-content split matters when you are reading the audit trail. A version history that shows three entries does not mean three name changes; it means the body changed three times. Renames and re-taggings happen out of band. A single update call can carry both kinds at once (new name plus new content); the result is one version bump, not two.
What the version history looks like
When you ask the agent for the history of an asset, it calls list_versions and you get back a list. Each entry has the same shape, and reading it well is the difference between a confident revert and a guess. The fields below are what each entry carries.
What list_versions returns for each entry
version
The integer position in history. v1 is the original save. Each content update increments by one.
created_at
When this version of the content was written. Use this to correlate with chat sessions or audit log entries.
created_by
Email of the user whose session produced this version. Useful when more than one editor has access through editor-share.
change_summary
What the version was for. A targeted edit carries the summary you gave it ("correct the YoY figure"), or a generated one naming how many edits it applied. A whole-body replacement reads "Content updated via MCP", and a rollback reads "Reverted from v{N}". This is the field that makes a history worth scanning, so it is worth saying what a change is for when you ask for it.
size_bytes
Body size at the time of the version. A sudden drop or spike is worth noticing when you are auditing.
content_type
What kind of file this version was: an HTML report, a markdown document, a CSV. Usually constant across versions; if it changed, that was an intentional shape change.
Default page size is 50 versions, which is more than most assets ever accumulate. For an asset with more history than that, ask the agent to raise the limit explicitly: the list_versions action takes a limit argument but not an offset, so a single call has to fetch everything you want to see.

How revert actually works
Revert is the one mechanic in this lesson that frequently surprises people on the first use. It does what you want at the level of "the asset now shows the old content," but the way it gets there is worth knowing so the audit trail makes sense afterward.
Who can edit what
The agent path and the portal path do not allow exactly the same operations to the same set of users. The difference is small but worth knowing if you ever share an asset with editor permission and your collaborator asks why the agent will not let them update it. Editing rights follow the same least privilege as the starting point that governs the rest of the platform.
A note on the portal edit surface
Most of this article assumes the agent path because it is the most common workflow. The portal has its own surface for editing assets you own and (with an editor share) assets others have shared with you. Both surfaces produce versions the same way; the rules above apply identically.

What this looks like in practice
A real session, running from the smallest kind of change to the largest. The user asks for one chart to be recolored, then for the dashboard to be rebuilt against a corrected source, then realizes the corrected source was itself wrong, asks for the version history, and reverts. The asset URL never changes across any of it.
One targeted change, one full update, one revert
You
The revenue chart in the regional sales review is blue and the board deck is green. Change just that chart to green.
Agent
Done. I found the revenue chart in the dashboard and recolored it in place. Nothing else in the document was touched.
New current_version: 3. Change summary: recolor the revenue chart to green.
One edit, six lines changed. The rest of the report is what it was.
You
The Southwest Q3 numbers in the regional sales review are wrong. Re-run the query against the corrected source table and replace the dashboard content with the updated numbers. Keep the same asset.
Agent
Done. I re-ran the regional revenue query against the corrected source table and updated the dashboard content. Same asset, same URL.
Asset: portal/assets/{asset_id}
Previous current_version: 3. New current_version: 4. Change summary: Content updated via MCP.
You
Wait, the Southwest column went down again after the update; the corrected source table looks wrong. Show me the version history and revert to version 3 while we sort it out.
Agent
Version history (most recent first):
v4 - 2026-05-16 - Content updated via MCP - [email protected]
v3 - 2026-05-15 - recolor the revenue chart to green - [email protected]
v2 - 2026-05-14 - Content updated via MCP - [email protected]
v1 - 2026-05-13 - Initial version - [email protected]
Reverted. New current_version: 5. Change summary: Reverted from v3. The body now matches what was at v3. v4 is still in the history so we can see what the bad data looked like.
The portal URL did not change across any of it. Any share link you handed out before turn one still points at the same asset; the recipient sees v5 on their next view. The history is auditable end to end: an analyst tomorrow can see exactly which version of the data was current at every point this week, and the recolor at v3 reads as a recolor rather than as another content change of unknown scope.
Prompting tips for editing
Four small phrasings make the agent path produce what you wanted consistently. None of them require knowing how the Manage Asset actions work internally.
Prompting tips for editing
Describe the change, not the deliverable. "Change the subtitle on the revenue chart to Q3 FY26" gets you a targeted edit. "Rebuild the dashboard with the new subtitle" invites the agent to regenerate a document that was fine.
Say "update the existing X" or "edit the X in place" so the agent picks update over save_asset. A prompt that just asks the agent to "redo X with the new numbers" sometimes produces a new asset and a new URL.
When you want a metadata change, say so explicitly: "rename to Y" or "set the description to Z" or "replace the tags with A, B, C". The agent will not bump the version, and the audit trail stays clean.
When you want to revert, ask for the version history first. A revert by recency ("go back one version") is almost always wrong; revert by version number is what you want.
Editing habits worth building
The mechanics are not the hard part of editing well. The habits are. Three of them carry most of the value.
Editing moves worth building into your habits
Read the history before you revert
A 60-second list_versions check turns a guess ("go back one") into a deliberate decision ("revert to v3"). The version with the right body is rarely the one immediately before the one you regret.
Treat the asset, not the chat, as canonical
Across a multi-day analysis, the chat will scroll, the prompts will accumulate, the answers will drift. The asset is the one place the right numbers live. Updating it after every meaningful correction means the URL you shared yesterday is still the source of truth today.
Use rename and re-tag freely
Metadata edits are cheap. They do not bump the version. If a name turns out to be confusing six weeks in, rename. If you realize a tag would help search, add it. The audit trail stays focused on the content changes that actually matter.
What 306 covers
A version history tells you what changed and when, but not how. The other half of the audit story is provenance: the catalog searches and queries the agent invoked during the producing session, with what parameters. 306 opens that record and names what it can and cannot tell you (prompts and agent responses, for example, are not in it).
Key terms
Nine terms cover the vocabulary of editing. The first three are the targeted-edit moves. The next four are the Manage Asset mechanics behind versions and rollback. The last two are the audit-trail field and the share kind that bring non-owner contributors into the picture.
Key Terms
- Targeted editaction=patch
- The Manage Asset (
manage_asset) action behind “change just this part.” The agent sends the change rather than the whole document, everything outside the named part is left untouched, and the result is an ordinary new version. - Outlineaction=outline
- What is in a document: its headings, and on a dashboard the panels and charts you can address by name. This is what the agent reads when you say "the second chart" and it needs to know which one you mean.
- Version comparisonaction=diff
- The changed parts between two versions, without the parts that stayed the same. Ask for it when you want to confirm what an edit did instead of re-reading the document.
- action=update
- The Manage Asset (
manage_asset) action that replaces an asset's whole body, or changes its name, description, or tags. Owner-only. Metadata changes do not bump current_version; content changes do. - current_version
- The integer position of the most recent version. Starts at 1 on save_asset. Increments on every content change, targeted or wholesale, and on every revert. Never decrements.
- list_versions
- Action that returns the version history for an asset. Each entry has version, created_at, created_by, change_summary, size_bytes, and content_type. Default page size: 50.
- revert
- Action that creates a new version whose content is copied from an older version. Does not erase newer versions; the rollback itself is a versioned event with change_summary "Reverted from v{N}".
- change_summary
- Short label on each version explaining what happened. "Initial version" for v1, your own words on a targeted edit, "Content updated via MCP" for a whole-body replacement, "Reverted from v{N}" for reverts.
- Editor share
- A user share with
permission=editor(from 303) that lets a recipient update an asset's content from the portal. The agent path remains owner-only.
