Export and import
Every workflow becomes a scene: its data, its tools, the agent that runs it, and the history of everything it did. A scene can also be written to disk. What comes out is a folder of plain files: markdown for notes, HTML for views, JSON for values, and one small file describing the scene itself. Push the folder back and you get the same scene. There is one exporter and one importer; a folder on disk, a copy of another scene and a blueprint all go through the same two. This page shows the folder, the two commands that move it, and what else the folder can be. The folder is the scene at one moment; to move the scene with its history, see Scenes to git and back.
A scene on disk is a folder of files you already know how to read
Take a scene that prepares a quarterly review. Written to disk it looks like this:
qbr/
├── scene.json # the scene, and its cells that are not files
├── notes/prep.md # a note the agent keeps
├── views/dashboard.html # a view someone made
├── views/dashboard.data.json # the value that view draws
├── tables/accounts.jsonl # a table, one row per line
└── scenes/drafts/ # a child scene, same layout againNothing was translated to get here. A note is stored as markdown and a view as HTML; the export lays them on disk under the names they already have, and the import reads the same tree back. A table's rows are written out for reading, one JSON object per line; pushing the folder back leaves a table's rows as they are in the scene.
scene.json carries the scene and every cell that is not a file
{
"name": "Quarterly review",
"slug": "qbr",
"description": "Revenue, churn and the three decisions for the board",
"icon": "chart.bar",
"tint": "2563EB",
"fields": {
"category": "finance",
"tags": ["board", "quarterly"],
"tagline": "The board pack, kept current by the agent"
},
"assets": [ … ],
"linkedAssets": [ … ]
}fields is an open set of facts about the scene, read by the product where it needs them: a scene's page, its card in a list, and the agent reading the scene all take their description from here. The cells that are not files, a formula or a connected repository, are listed under assets, and cells this scene shows from elsewhere in the workspace under linkedAssets.
Two commands move the folder in either direction
daslab scene export --out ./qbr # the current scene → a folder
daslab scene push ./qbr # a folder → your workspaceexport writes the folder above, or with --json the same scene as one .blueprint.json file for a gist or a paste (Blueprints describes that document). push takes either, a folder or the one file, and an integration's folder the same way. Because nothing is translated in either direction, you can edit a scene in your editor, push it, let the agent and your team change it in the app, and export the result again.
An import merges, commits, and remembers where it came from
Exporting records which commit the folder came from. When you push the folder back, the importer compares that commit to the scene's current head and merges cell by cell: a cell you changed that nobody else touched applies, and a cell that moved on in the app while you were editing is reported as a conflict. By default the import proceeds with your version and tells you what it overrode.
daslab scene push ./qbr --strict # refuse while any conflict stands
daslab scene push ./qbr --replace # the folder is the whole truth: files absent from it are removed--replace is what an integration author wants when pushing their own folder; merge is what everyone else wants. Each import lands on the scene's commit chain as one commit per scene touched, with the actor and a message saying where it came from. So the timeline reads "copied from …" or "provisioned from …" in the same place it reads "agent wrote …".
A scene can come from three places
A folder or a file on disk, yours or a checkout: daslab scene push ./folder, or daslab scene push ./qbr.blueprint.json.
Another scene, copied into your workspace with everything in it you can read. Content arrives as your workspace's own, and anything that needs a connection waits as a tile to connect. The copy does not follow the original afterwards; its first commit says where it came from.
A blueprint. Starting a scene from one imports it with your inputs filled in, and the new scene's first commit records the blueprint and the inputs it was given.
Credentials are references on both ends
Export never writes a secret. Credential fields (api_key, access_token, client_secret, …) are sealed out of the export and replaced by a reference, kern:NAME for the encrypted vault or env:NAME for the server environment. Import resolves the reference. A credential that lives only on your machine rides the request as daslab blueprint push … --secret type:id:field=value, encrypted in transit and never written to disk. A folder with connected accounts in it is safe to commit, share and copy.
A scene is an integration when its cells have the right shape
No scene declares "I am an integration". A scene that holds tools grouped under cell types is one, and it is loaded as one. Here is the Kenko integration, a booking system's API, which runs on daslab.run from exactly this folder:
kenko/
├── scene.json
├── lib/client.ts # the API client, written once
├── assets/
│ ├── account/
│ │ ├── asset.json # what connecting asks for: API key, center id
│ │ └── tools/list_centers.ts # tools that act on the account
│ ├── schedule/ # "Class"
│ │ ├── asset.json # name, fields, how it displays, its card
│ │ └── tools/list_schedules.ts # tools that act on classes
│ ├── contact/ # "Member"
│ └── booking/ # parent: contact
├── browse.ts # feeds the picker: classes, members, bookings
└── kb/
└── partner-api.md # a guideEach folder under assets/ is a cell type. account is the connection: its asset.json lists the credential fields the connect form asks for, and every tool receives all of them. An integration without an assets/account/ folder needs no key; Open-Meteo and Poly Haven are built that way. A folder integration connects with an API key, in one field or several, or with nothing at all; integrations that sign in with OAuth are built into Daslab. The other folders are the things a person browses and adds to a scene, each with the tools that act on it.
Push this folder into your workspace and the integration is there on the next job: the picker shows classes and members, the agent has the tools, the connect form asks for the key. An integration from a folder is built fresh for each job, so a change you push is live on the next one with nothing to restart. Its tools reach only the jobs of scenes that hold one of its cells.
A tool is one file, and the file describes itself
// assets/schedule/tools/list_schedules.ts
import { defineTool } from "@daslabhq/asset-provider";
import { request, collection } from "../../../lib/client";
export default defineTool({
description: "List public class sessions available for partner booking, ordered by start date.",
readOnly: true,
input: {
start_date: { type: "string", description: "YYYY-MM-DD" },
end_date: { type: "string", description: "YYYY-MM-DD, on or after start_date" },
},
async run(input, ctx) {
return collection(await request(ctx.credential, "/schedules", { query: input }), "schedules");
},
});The tool's name is its path: kenko, then the file, then the cell type, so this one is kenko_list_schedules. Its description and input schema are read out of the file itself; there is no second copy in any manifest. A tool that is a single HTTP request needs no code at all, only a list.http.json holding the templated request, with {{credential.api_key}} and {{input.query}} where the values go. A write that should pause for a person says requiresApproval: true, and the job stops there until someone approves it.
kb/ is the knowledge base
Every markdown file in kb/ is a guide. The filename is its slug, and the first heading is its title. For an integration Daslab serves, the guides are on its page, and the agent reads them with docs_read in any scene, before anything is connected. Kenko's three guides, on the Partner API, on where its payment data actually lives, and on connecting a studio, are three files in that folder. Knowledge bases covers the rest.
Open integrations are reviewed in public before they go live
The open integrations live in one repository, daslabhq/asset-providers: the folder format, a validator, a local runner, and worked examples. Anyone can write an integration there and test it with no account:
bun cli/validate.ts providers/yourprovider
bun cli/run.ts providers/yourprovider yourprovider_search '{"query":"test"}' --credential api_key=…Merging a pull request does not put code in front of Daslab users. Daslab pins the repository at one reviewed commit and names the integrations it takes from it; only those are copied in, and a folder that is present but not named never loads. Kenko and Open-Meteo are among the integrations served from that repository today.
Where to look next
Scenes to git and back moves the scene with its history; Blueprints is the same scene as one JSON document; Providers covers what an integration brings; Layers covers who can see a scene and its share link; the CLI has every flag.
Updated 2026-11-14