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.

Live demo · Documentation · Getting started

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: alpha. Before 1.0 a minor release may change the ledger model, the ingest API or the command line; the changelog lists each such change.

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 removed guardrails 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?" Entities match exactly, so this works within each platform today; matching the same API across platforms is the next milestone.
• 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.

How it runs

Pipelines you already run record each agent: a pull request records the proposed definition and gets a comment ranking its changes, a deploy records what was shipped, and an optional scheduled export records what is live in a web designer. See the GitHub Action, Jenkins and Azure DevOps and Deployment.

Formats

Readers are tested against real, public definitions, pinned to a commit. No writer's output has yet been imported into a hosted platform; see how each format is verified.

Try it

Browse the live demo, or build it yourself from 28 public agents, with nothing to install but uv:

$ uvx --from 'marshal-ledger[server]' marshal demo
$ uvx --from 'marshal-ledger[server]' marshal web --db demo.sqlite

Or pip install 'marshal-ledger[server]', then marshal demo and 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 my-team/my_agent                      # proposed against shipped, ranked by risk
$ marshal status my-team/my_agent                    # shipped vs live per environment, drift, freshness
$ marshal deps "*my_tool" --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 my-team/my_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

The documentation is published at marshal-ledger.github.io/marshal.

• Getting started
• Guides: Copilot Studio inventory, pull request review, agents in code, drift, ADK to Agent Spec, audit evidence
• How Marshal compares with platform admin tools, observability, AI gateways, registries and governance platforms
• 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, Jenkins and Azure DevOps and Deployment
• Security review: what is stored, authentication, network, supply chain, retention and audit, for security reviewers

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.