Assembly Line

Assembly Line is a vendor-neutral, filesystem-first framework for durable AI agents. An agent is an ordinary folder. The compiler validates that folder and builds a deterministic manifest and runtime artifact. The runtime then executes the agent through explicit channels, infrastructure profiles, and selected plugins declared in agent.md.

Each authored surface has one role. Root skills are auto-discovered; local plugins live under plugins/<name>/ and expose Agent Plugins v1 plus the ai.assemblyline extension. Official packages use the same public contracts, so agents can add channels, connections, sandboxes, tools, and infrastructure providers, including model providers, without root executable folders or framework-core changes.

Mental Model

agent/ folder      what the agent is
compiler           validates the folder and emits a manifest plus .assembly-line artifact
runtime            executes runs durably and records events, tools, deliveries, and recovery state
workspace          hydrates a disposable sandbox from versioned state and content-addressed blobs
  agent.md           declares intent, channels, infrastructure, plugins, routines, and subagents
  plugins            add models, channels, connections, tools, sandboxes, state, blob, deploy, and companions

A minimal agent needs agent.md; default context and framework capabilities are supplied automatically. Add a root skill, select a plugin, or declare a channel, automation, infrastructure profile, or subagent in agent.md as the agent grows.

Start Here

1. Getting Started - clone the repo, build it, run the example agent, create a new agent, and inspect the compiled artifact.
2. MD-First Agents - learn the declarative model and grow an agent from one file.
3. Migrating to Assembly Line 6 - replace the pre-6 TypeScript authoring surface with the Markdown-first, plugin-first contract.
4. Declarative Reference - the canonical agent.md grammar for every accepted field, default, plugin selection, and typed deviation.
5. Agent Build Stack - navigate the agent folder by the file or directory you are editing.
6. Building Agents - the linear tutorial through the whole authoring path.
7. Coding Agents - install version-matched Assembly Line guidance for Codex and Claude Code.
8. Runtime And Deployment - understand the compiler output, durable runtime lifecycle, HTTP endpoints, preflight checks, and deploy targets.
9. Configuration And Credentials - understand scoped configuration, brokered connection credentials, sandbox leases, and secure browser fills.
10. Troubleshooting - diagnose install, CLI, model-key, auth, preflight, ingress, and durability-worker failures.

Agent Build Stack

Start at the Agent Build Stack overview, then jump to the file you are editing:

• MD-First Agents - the complete agent.md, plugin, skill, channel, automation, schedule, and subagent contract.
• Plugins - published IDs, local plugin discovery, Agent Plugins v1, and ai.assemblyline extensions.
• Gateway, channels, and runtime - explicit provider profiles and durable runtime boundaries.
• evals/ - golden cases, custom evaluators, repeatable experiments, and baseline gates.
• Observability - telemetry profiles, plugin sinks, and capture policy.

Guides

• MD-First Agents - the supported authoring model, defaults, plugin ownership, and validation flow.
• Migrating to Assembly Line 6 - the breaking source-layout, plugin, configuration, and credential changes from the pre-6 framework.
• Building Agents - the canonical flow from agent.md through Skills, plugins, channels, automations, subagents, and inspection.
• Coding Agents - project-scoped Codex and Claude Code skills, version-matched docs, MCP access, and structured validation.
• Customizing Agents - context policy, gateway adapters, capability metadata, approvals, self-improvement, dynamic automations and connections, and observability.
• Runtime And Deployment - CLI commands, build artifacts, runtime lifecycle, HTTP endpoints, preflight, deploy targets, and production checks.
• Troubleshooting - common failures with the exact error text and the fix.
• Remote Computer Use - pair a Mac with a hosted agent through Computer Host and an end-to-end encrypted relay.
• GitHub App sandbox access - materialize one-hour Git and GitHub CLI credentials whose authority comes from the App installation.
• Agent-To-Agent (A2A) - expose standard Agent Cards and connect independently deployed agents through A2A v1.0.

Plugins And Providers

• Plugins - install optional Assembly Line integrations and understand how plugin contributions map to providers, adapters, connections, tool packs, and companions.
• Adapters - consume substrate adapters: the role matrix, gateway config, and per-adapter env reference.
• Photon iMessage Channel - Photon/Spectrum channel setup, delivery modes, typing lifecycle, rich tools, and file handling.
• Authoring Plugins - implement model providers, channels, connections, sandboxes, blob stores, deploy targets, and state stores as plugin contributions.

Reference

• Framework Guide - current framework contracts, manifest shape, runtime guarantees, package boundaries, and adapter boundaries.
• Declarative Reference - the canonical agent.md field, default, plugin-selection, and typed-deviation contract.
• Runtime Configuration - runtime environment variables and operator configuration.
• Configuration And Credentials - the runtime secret boundary and plugin migration guide.
• Architecture - system shape, trust boundaries, and package ownership.
• Contributing - work on the Assembly Line framework itself and keep developer docs current.