Repo

Every Skydive agent is backed by a private git repository. It’s the source of truth for everything that makes the agent this agent rather than a generic one: its persona, what it knows, the tools it has, and the code it runs. You can explore it, edit it, and commit to it just like any other repository.

Where the repository lives

Inside the agent’s sandbox, the repository is mounted at /home/user/.self. The agent commits and pushes its changes automatically, so everything it learns and configures is persisted across sandbox restarts.

What’s in it

.self/
├── soul.md             # Persona and standing instructions
├── mcp.config.json     # MCP server connections
├── tools/              # Custom in-process tools
├── skills/             # Reusable workflows (one folder per skill)
│   └── <skill>/
│       └── SKILL.md
├── .memory/            # Persistent memory files
│   ├── users/
│   ├── projects/
│   └── reference/
├── Dockerfile          # Baked-in packages and dependencies
├── start.sh            # Credentialed setup that runs at boot
├── webserver.sh        # Starts the agent's web server (if any)
└── index.ts            # Agent harness entrypoint

`soul.md`

The agent’s persona. It’s the same content you can edit through the dashboard, but here you can version it, diff it, and PR it. The agent reads this at the start of every conversation.

`mcp.config.json`

Which MCP servers the agent has connected. Add a server here and the agent picks it up on its next turn:

{
  "servers": {
    "my-server": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "some-mcp-package"]
    }
  }
}

Optional per-server fields pick which tools register:

tools: only these tool names register.
excludeTools: these tool names never register.

If you set both, tools applies first, then excludeTools removes from what’s left. An empty tools array is the same as leaving it out. Edits take effect on the next turn; the agent doesn’t reconnect the server.

{
  "servers": {
    "my-server": {
      "transport": "stdio",
      "command": "npx",
      "args": ["-y", "some-mcp-package"],
      "tools": ["search", "create_issue"],
      "excludeTools": ["delete_all"]
    }
  }
}

See Tools & MCP for the full connection patterns.

`tools/`

Custom in-process tools the agent can call. Each .ts or .mjs file here exports a ToolDefinition. The agent picks up new files without a restart. Files starting with _ or . are skipped.

`skills/`

One subdirectory per skill. Each contains a SKILL.md with YAML frontmatter (name, description) and the workflow instructions. The agent re-scans this on every conversation, so editing a skill file takes effect immediately. See Skills.

`.memory/`

The agent’s persistent memory, organized as plain markdown files. The directory structure reflects how the agent groups what it knows:

.memory/
├── users/<name>/       # What the agent knows about specific people
├── projects/<name>/    # Context, decisions, and status per project
└── reference/          # How external systems are set up

You can read these to understand what the agent has learned, and you can edit or delete them to correct stale facts. The agent reads from this at the start of each conversation. See Memory.

`Dockerfile`

Packages and system dependencies baked into the agent’s image. Anything installed here survives sandbox restarts. Use it for tools the agent needs reliably:

RUN apt-get update && apt-get install -y ffmpeg
RUN npm install -g some-global-tool

Changes take effect on the next image build.

`start.sh`

Setup that runs at boot, after credentials are available. This is where you put steps that need secrets or network identity, like cloning a private external repository. The Dockerfile runs at build time with no credentials; start.sh runs at runtime with full access to secrets and the git credential helper.

Exploring an agent’s state

To see what an agent remembers, inspect .memory/ in the repository. To see which tools it has, look in tools/ and mcp.config.json. The persona is in soul.md.

# Read the agent's persona
cat .self/soul.md

# See which MCP servers are wired up
cat .self/mcp.config.json

# Browse memory files
ls .self/.memory/
cat .self/.memory/projects/my-project/state.md

Making changes

Changes committed and pushed to the agent’s repository take effect on its next run. The agent’s sandbox is rebuilt from the Dockerfile on push, so package changes need a push to persist. In-conversation changes (memory writes, tool additions, MCP config edits) are committed by the agent automatically.

The .memory/ directory uses plain markdown files. Editing them directly is safe, but the agent may overwrite a file if it writes a newer version in its next conversation. Treat direct edits as corrections, not long-term overrides.

Exporting an agent

An agent’s repo is the agent. Persona, memory, skills, tools, and MCP config all live in it, so cloning it is a full export of the agent’s setup. Nothing else is needed to reconstruct the agent elsewhere. In the app, open the agent’s Computer panel, switch to the Version History tab, and click Copy clone URL. It mints a git token and copies the full clone URL to your clipboard:

git clone <paste the URL here>

The same URL is available from Manage version history in the agent’s ··· menu. Editors get a read/write token; viewers get a read-only one. See Version history for the token details.

The repo holds the agent’s setup and knowledge. Conversations and workspace data are separate from it.

Tools & MCP

How the agent extends its toolset.

Memory

How agents accumulate and recall knowledge.

Skills

Reusable workflows stored in the repository.

Persona

The standing instructions in soul.md.

Platform CLI

The runtime commands the agent runs inside its sandbox.

Get started

Agents

Talk to them

Computer

Integrations

Workspaces

Where the repository lives

What’s in it

`soul.md`

`mcp.config.json`

`tools/`

`skills/`

`.memory/`

`Dockerfile`

`start.sh`

Exploring an agent’s state

Making changes

Exporting an agent

Tools & MCP

Memory

Skills

Persona

Platform CLI

​Where the repository lives

​What’s in it

​soul.md

​mcp.config.json

​tools/

​skills/

​.memory/

​Dockerfile

​start.sh

​Exploring an agent’s state

​Making changes

​Exporting an agent

Tools & MCP

Memory

Skills

Persona

Platform CLI

Where the repository lives

What’s in it

`soul.md`

`mcp.config.json`

`tools/`

`skills/`

`.memory/`

`Dockerfile`

`start.sh`

Exploring an agent’s state

Making changes

Exporting an agent