Keep a Semantic Kernel Note for the Next Worker

Save a Markdown note through a Semantic Kernel native function, then read the same file in a fresh worker.

Your Semantic Kernel app reviews a code change in a temporary worker. It writes a Markdown summary, then the worker is removed along with its local files. The next task cannot open that summary.

mountable.io is a persistent filesystem for AI agents. Save the note there before the worker exits. A second worker can read the same file through its own native function.

A database record can preserve text too. A shared Markdown file fits when people, scripts and other workers need to open the same output through a CLI, SDK or mount.

Worker A invokes write_note through a Semantic Kernel plugin and stores a Markdown note on mountable.io. After it exits, worker B invokes read_note and opens the same file. — Each worker has its own Kernel. Both functions use the same saved file.

Two functions, one saved note

Your backend chooses the user's filesystem and note path before it constructs the plugin. The write function accepts only note text. Its core is small:

from semantic_kernel.functions import kernel_function
 
class NotesPlugin:
    def __init__(self, store, path):
        self.store, self.path = store, path
 
    @kernel_function(description="Create the application-selected note.")
    def write_note(self, text: str) -> str:
        self.store.write(self.path, text, if_none_match=True)
        return "stored"

Register the plugin with Kernel.add_plugin, then call Kernel.invoke with the plugin and function names. The read function opens the file through the SDK. A new Kernel in the second worker gets the stored bytes rather than the first function's acknowledgement.

Try the handoff

Use an existing mountable.io account and filesystem, with your API key in a private environment. Hosted storage and downloads are billed at the published prices. The example calls both functions through Kernel.invoke without calling a model, so you can try it without a model key.

After the setup in the guide, run these commands in separate processes:

uv run python notes.py write --filesystem "$FS_ID" --path "$NOTE_PATH" --text "$NOTE_TEXT"
uv run python notes.py read --filesystem "$FS_ID" --path "$NOTE_PATH"

The first prints stored. The second prints Parser review complete. Open the stored note. We ran this handoff against production with Semantic Kernel 1.45.0 and mountable-sdk 0.3.0.

The write preserves the first note if the task tries to create it twice. The second worker uses a read-only SDK session, so it can read without replacing the file. The full example checks text size and arguments before dispatch and raises storage failures as errors.

Follow the guide for setup, expected output and cleanup, or open the runnable source. Delete the note when the workers no longer need it. mountable.io maintains this community example separately from Microsoft.