Marshal — an agent ledger

A vendor-neutral, open-source ledger for enterprise AI agents. Any format in, any format out, with versions, diffs, portability and audit across every platform.

Marshal reads the agent definitions teams already produce: Databricks bundles, Copilot Studio agents, Bedrock templates, Agentforce metadata, agent code and the open standards. It builds a normalized, versioned record of every agent: what model it asks for, what tools and data it can reach, and who it acts as. Every field says where its value came from, and nothing is guessed.

Status: pre-alpha.

What it does

• Inventory of every agent across platforms, with versions, deployments, and each record's completeness.
• Risk-ranked review: pull requests that change an agent get a comment that lists permission escalations, new write tools and model changes first.
• Drift and freshness: compares what is live with what was shipped, and shows how recently each record was confirmed and by which channel.
• Dependencies: "who uses this tool, this knowledge source, this permission?" across every platform.
• Translation between formats, with a fidelity report computed by reading the result back.
• Portability scores for moving an agent to another platform, from a community-maintained capability matrix.
• No shared secrets: pipelines push records authenticated by their CI provider's OIDC token. Marshal never connects to agent platforms.

Formats

Try it

Build a demo from 28 public agents and browse it:

$ pip install 'marshal-ledger[server]'
$ marshal demo
$ marshal web --db demo.sqlite

marshal demo downloads the agents' definitions from their public GitHub repositories, pinned to a commit.

Then on your own agents. See Getting started:

$ marshal read path/to/bundle                        # print ledger records
$ marshal collect path/to/bundle --target prod --event shipped
$ marshal ls                                         # every agent, latest version, where it is shipped
$ marshal diff finance/invoice_agent                 # proposed against shipped, ranked by risk
$ marshal status finance/invoice_agent               # shipped vs live per environment, drift, freshness
$ marshal deps "*CheckWeather" --shipped             # who depends on this, and where it is live
$ marshal convert agent.adl.yaml --to agent-spec     # translate, with a fidelity report
$ marshal port finance/invoice_agent --to all        # portability to every platform
$ marshal web                                        # browse the store

collect writes to a local SQLite store (marshal.sqlite, or --db / $MARSHAL_DB). In a shared deployment, pipelines run marshal push or the GitHub Action against the ingest API. Optional scheduled workflows export agents built in a web designer, such as Copilot Studio and Agentforce, and report drift from what was shipped.

Documentation

• Getting started
• Design: the problem, architecture, security and network posture, roadmap
• Ledger model v0: records, provenance, version hashing, the version store, risk ranking, freshness
• Conversion and fidelity and Portability
• Formats: Databricks, CloudFormation, Copilot Studio, Agentforce, ADK Agent Config, Vertex AI Agent Engine, Python agent code, ADL, Agent Spec, OASF, Marshal file
• Platform exportability: what each closed platform exposes
• Ingest API, GitHub Action and Deployment

Development

$ pip install -e '.[dev]'
$ python scripts/fetch_fixtures.py     # golden fixtures: real public agent definitions, pinned by commit
$ pytest

See Contributing. Golden fixtures are fetched rather than committed, so each file stays under its upstream license. After changing the model, regenerate the schema with python scripts/generate_schema.py. Report vulnerabilities as described in Security.

License

Marshal is licensed under the Apache License 2.0.