Hello World Agent Application

The smallest useful Agent Application can return to work it saved during an earlier run and decide what to do next from the state it finds. This example is a notebook agent for one user. It saves notes in its workspace and maintains a short briefing the user can open without reading the conversation. The files live in examples/durable-notebook/. For this walkthrough, we will use Goose as the harness / Agent Application Framework, and Dharta as the Agent Application Platform to deploy the agent. Same agent can be written for other harness/frameworks, with corresponding folder structure and that agent can be deployed to platforms that support that particular harness.

0: Agent project folder

The paper describes an Agent Project by parts, not by specific filenames:

agent-application/
|-- natural-language-instructions
|-- computer-code-tools
|-- system-integrations
|-- evaluations
|-- package-dependencies
|-- platform-configuration
`-- ...

Goose maps those parts onto its own files. After this point the example uses only that Goose layout:

examples/durable-notebook/
|-- AGENTS.md                 # natural-language-instructions
|-- skills/                   # natural-language-instructions (empty in this app)
|-- tools/
|   `-- save-note.ts          # computer-code-tools
|-- evals/
|   `-- persistence.yaml      # evaluations
|-- recipe.yaml               # Goose recipe for goose run
|-- package.json              # package-dependencies
`-- dharta.toml               # platform-configuration, used in section 4

1. Framework selection

Pick a harness that can load instructions, call tools, keep a working directory across sessions, and later run as a native project on a platform. This example uses Goose because it is open source, model-agnostic, and already compared in the paper’s capability model. The same application can be written for other harnesses such as Claude Code and Deep Agents. Install the Goose CLI and configure a model:

curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash
goose configure

On macOS you can instead run brew install block-goose-cli. First launch asks you to choose a provider. See Goose’s installation guide.

2. Agent Application Programming

Agent Application Programming is designing, authoring, and evaluating the hybrid program. The result is an Agent Project in Goose’s native layout, using the parts from section 12.2. The job: one user, a research notebook, durable notes and a briefing. The privacy boundary is that user. The walkthrough uses two example users, Ada and Bea. They are different people and must not share a workspace. Natural-language instructions. Goose loads AGENTS.md from this directory when a session starts. This app has no skills, so skills/ stays empty.

You maintain a research notebook for one user in this working directory.

When the user asks you to remember something, run:

    node tools/save-note.ts "<the text to remember>"

Do not append to notes.md any other way. When asked for a briefing, read
notes.md and write or update briefing.md with the write tool.

Computer-code tools. tools/save-note.ts is a script Goose runs with the developer shell tool:

import { appendFile } from "node:fs/promises";

const text = process.argv.slice(2).join(" ").trim();
if (!text) {
  console.error("usage: node tools/save-note.ts <text>");
  process.exit(1);
}

await appendFile("notes.md", `- ${new Date().toISOString()}: ${text}\n`);
console.log("saved notes.md");

System integrations. None in this app. The notebook does not call MCP servers or other connectors. Evaluations. evals/persistence.yaml is the behavior to keep: Ada’s note survives suspension, and Bea cannot see it. Package dependencies. package.json marks the folder as an ES module so Node can run tools/save-note.ts. Platform configuration. dharta.toml is used in section 4.

Choice	Notebook behavior
Natural-language instructions	Load `AGENTS.md` when Goose starts in this directory
Computer-code tools	Run `node tools/save-note.ts` to append notes; write `briefing.md` with Goose’s write tool
Instance routing	One instance per user, each with a workspace the others cannot reach
Workspace	Keep files between sessions. Isolation is a dedicated virtual filesystem per instance, not two folders on one disk
Artifact	Present `briefing.md` as durable output the user can open
Background work	None for this example

3. Local testing

Local Goose checks that the notebook continues in the same folder after the process exits. The developer builtin is required so Goose can run the save script and write files. Stay in the project:

cd examples/durable-notebook
goose session --with-builtin developer

Say: “Remember that the launch moved to September 18.” Exit. notes.md should still be in this directory. Start Goose again in the same folder:

goose session --with-builtin developer

Say: “Prepare a launch briefing.” The agent should read the earlier note and write briefing.md. You can also run one turn without the interactive prompt:

goose run --with-builtin developer --recipe recipe.yaml \
  --params task="Remember that the launch moved to September 18."
goose run --with-builtin developer --recipe recipe.yaml \
  --params task="Prepare a launch briefing."

goose configure must have a model. recipe.yaml is valid Goose recipe input (goose recipe validate recipe.yaml).

Defining property	Where it appears locally
Persistent agent instance	The second session returns to the same project folder
Agent-directed control flow	Goose chooses whether to write a note, read notes, or revise the briefing
Durable computational workspace	Files remain after `goose session` exits
Durable work	`notes.md` and `briefing.md` outlive the conversations that created them

On Monday, Ada says, “Remember that the launch moved to September 18.” On Friday she asks for a briefing. The same workspace, durable artifact. Ada and Bea still must not share a workspace. Copying the project into two folders on the same disk does not provide that isolation. The agent can see the whole filesystem, and a natural-language rule not to look in the other folder is not a privacy boundary. Each user needs an instance whose workspace is a dedicated virtual filesystem the other instance cannot reach. That is platform work, in section 4. The YAML eval states both checks: Ada’s note survives suspension, and Bea cannot see it. Local Goose covers the first. The second needs isolated instances.

4. Agent Application Platform deployment

A platform turns the tested Goose project into a release and operates long-lived instances. It provisions an instance at the notebook’s privacy boundary (one user), attaches a dedicated virtual filesystem as that instance’s workspace, and serves a URL. Two signed-in users must get two instances. Their files never sit as sibling folders on one shared disk. Dharta is one platform that runs Goose projects in their native format. Install the CLI, sign in, enable deploy for this folder, and ship it:

npm install -g @dharta/cli
dharta login
cd examples/durable-notebook
dharta setup --enable --method git
dharta deploy
dharta open

Commands are from Dharta’s CLI overview and quickstart. Platform configuration is dharta.toml. It names the agent and selects the Goose harness:

name = "durable-notebook"
deploy = true

[harness]
type = "goose"
version = "1"

dharta deploy builds an immutable release and activates it at a stable URL. The platform then creates instances as users arrive. In Dharta, the instance is a karta: one id is one durable computer with its own workspace and memory. Map the id to Ada and to Bea. Each gets a private notebook. The same project, two instances. Open the hosted page (dharta open). Sign in as Ada, leave the September 18 note, sign out. Sign in as Bea. Bea must not see Ada’s notes. Sign in as Ada again; the briefing work is still there. dharta dev --user ada and dharta dev --user bea exercise that routing on your machine against the same session API production serves. They do not replace Goose’s own local workflow in section 3. The same hello-world-on-Goose shape, including other harness twins, is also published at dharta-ai/examples. This repository does not operate a platform.

Optional: the notebook as a plugin

The example above keeps save-note.ts in the project so its code is visible. Another version could get the note tool and briefing procedure from a portable plugin:

research-notebook-tools/
|-- plugin.json
|-- skills/
|   `-- briefing/
|       `-- SKILL.md
`-- mcp.json

The plugin uses the Agent Plugins 1.0 package format. Installation does not grant filesystem access or credentials. The plugin version must use the same instance routing and workspace isolation, and it must pass the same persistence test.

Overview

Concepts

About the paper

0: Agent project folder

1. Framework selection

2. Agent Application Programming

3. Local testing

4. Agent Application Platform deployment

Optional: the notebook as a plugin

​0: Agent project folder

​1. Framework selection

​2. Agent Application Programming

​3. Local testing

​4. Agent Application Platform deployment

​Optional: the notebook as a plugin

0: Agent project folder

1. Framework selection

2. Agent Application Programming

3. Local testing

4. Agent Application Platform deployment

Optional: the notebook as a plugin