What Developers Can Build on the Envelope Schema

Draft — April 2026

The Envelope Team Definition Schema is an open standard. The spec, JSON Schema file, and TypeScript types are public. Any developer can read a team definition, write one, validate one, or build tooling around one — without touching Envelope's proprietary infrastructure.

This creates a surface area for a developer ecosystem. The following is a map of everything that can be built on top of the schema, organised by category. Envelope doesn't need to build any of this — but knowing what's possible helps us recruit the right builders, write the right docs, and recognise ecosystem momentum when it appears.

1. Validation & linting

JSON Schema validator Any tool that accepts a .json file and checks it against schema.openenvelope.org/team/v1.json. The simplest possible entry point for a developer experimenting with the schema.

CI/CD linter A GitHub Action or GitLab CI step that runs @envelope/conform against every team definition file in a repository. Fails the build if the definition is invalid. Enterprises storing team definitions in Git repos would adopt this immediately.

Pre-commit hook A lightweight script (using husky or lefthook) that blocks commits containing invalid team definitions. Same audience as CI linting — teams working in code-first workflows.

IDE language server (LSP) A language server that provides real-time validation, field autocomplete, and inline error messages for .json and .yaml files that reference the Envelope schema. VS Code and JetBrains both support LSP. SchemaStore registration gives partial autocomplete today; a dedicated LSP gives a richer experience.

2. IDE & editor extensions

VS Code extension Beyond what SchemaStore provides: hover documentation for each field, a tree view of the agent hierarchy, one-click navigation between agents, inline warnings for missing reportsToKey on non-root agents, and a "preview" panel showing the team as an org chart.

JetBrains plugin Same feature set as the VS Code extension, targeting the enterprise developer audience who lives in IntelliJ, PyCharm, or WebStorm.

Neovim / Vim plugin Lightweight validation and autocomplete via nvim-lsp or coc.nvim. Small but highly visible audience — tends to produce the kind of developers who write about tools they love.

3. Visualisers & diagram tools

Org chart generator Takes a team definition and renders the agent hierarchy as a visual org chart. Could be a CLI that outputs SVG, a web app, or a VS Code panel. Useful for reviewing complex multi-agent structures before deploying.

Version diff viewer Takes two team definition files (or two versions from the Envelope registry) and shows a structured diff: which agents were added, removed, or changed, and what fields changed in each. Useful for code review and for deployers evaluating whether to accept an update.

Dependency graph Maps the reportsToKey relationships across a team definition and surfaces potential issues: agents with no supervisor, circular reporting chains, or agents with more direct reports than a given threshold.

4. Converters & importers

LangGraph → Envelope Reads a LangGraph graph definition and generates an approximate Envelope team definition. The mapping is imperfect (LangGraph is code-first), but a best-effort conversion that captures the agent structure and passes it into the Envelope editor is useful as a migration tool.

CrewAI → Envelope Same idea for CrewAI's YAML-based crew definitions. CrewAI's format is closer to declarative, making this a cleaner mapping.

AutoGen → Envelope AutoGen uses Python class definitions, so this requires parsing code rather than config. More complex, but AutoGen has a large user base.

Spreadsheet / CSV importer A tool that accepts a spreadsheet (columns: agent name, role, supervisor, model) and generates a valid Envelope team definition. Targets non-technical users and operations teams who think about agent hierarchies in spreadsheet terms.

Existing org chart → Envelope Takes a Lucidchart, Miro, or OrgChartNow export and generates an agent skeleton from the human org structure. A bridge between how organisations think today (human teams) and what they're building (multi-agent teams that mirror them).

5. Code generators

Envelope → Python / CrewAI Takes a team definition and emits a working CrewAI crew script. The inverse of the CrewAI importer. Useful for developers who want to run an Envelope-published team locally in a Python environment.

Envelope → LangGraph Same for LangGraph. Generates a graph definition from the agent hierarchy and role descriptions.

Envelope → TypeScript types Generates TypeScript interfaces from a specific team definition — not the schema types (which @envelope/schema already ships), but types specific to a team's declared outputs and tool shapes.

SDK generator Takes the Envelope registry API spec and generates a typed SDK in a target language (Python, Go, Ruby). Useful for deployers who want to call the install API from languages without an official client.

6. Testing & simulation

Local runtime simulator A lightweight tool that runs a team definition locally against a mocked task — no Paperclip account required. Useful for builders testing prompt logic during development. Could be as simple as a CLI that calls an LLM API with each agent's prompt in sequence.

Agent prompt tester A focused tool for testing individual agent prompts against sample inputs and inspecting outputs. Works from a team definition file; the developer picks an agent and a task, and the tool runs it.

Conformance test suite A test harness that a runtime implementer runs against their platform to verify they correctly handle all schema fields, run event shapes, and install/uninstall sequences. @envelope/conform is Envelope's implementation of this; a community-built version might target specific platforms or add stricter edge case coverage.

7. Runtime adapters (new platforms)

Any developer can write a platform adapter that reads an Envelope team definition and provisions agents on a new runtime. The adapter pattern is documented; the conformance suite verifies correctness.

Platforms not yet covered by first-party Envelope adapters that are candidates for community adapters:

LangGraph Cloud — needs a code generator rather than REST calls; Python community is the natural author
CrewAI — same as LangGraph
AutoGen — Microsoft's multi-agent framework, large enterprise audience
Dify — popular open-source LLM app platform, strong community
Flowise — visual LangChain builder, non-technical audience

Each community adapter is a multiplier: it expands where Envelope teams can run without Envelope building anything.

8. Enterprise & GitOps integrations

Terraform provider Manages Envelope team definitions as Terraform resources. Enterprises doing infrastructure-as-code can declare team installs alongside cloud resources. envelope_team_install as a Terraform resource type.

Kubernetes operator A Kubernetes custom resource definition (CRD) that watches for Envelope team definitions and triggers installs/updates when they change. Targets teams deploying agents as part of a cloud-native stack.

GitHub / GitLab integration A bot that posts a validation summary on every PR that touches team definition files. Shows which agents changed, flags schema errors, and optionally triggers a deploy to a staging environment on merge.

Secrets vault integration Pulls requiredSecrets values from HashiCorp Vault, AWS Secrets Manager, or 1Password and maps them to the install request automatically. Removes the manual secrets-entry step for enterprise deployers.

9. Observability & analytics

Run event consumer A library that subscribes to Envelope's run event webhook and pipes events into a destination: Datadog, Grafana, Splunk, or a custom data warehouse. Teams that want agent observability inside their existing monitoring stack.

Cost dashboard A tool that aggregates per_k_tokens run events across installs and produces a cost breakdown by agent, team, and company. Useful for deployers managing multiple installs who want to understand where token spend is going.

Audit log exporter Exports run events in a format suitable for compliance review: which agents ran, what tasks were invoked, what was returned, and when. Targets regulated industries where audit trails are a procurement requirement.

10. Discovery & registry tools

Private registry An organisation-internal version of the Envelope marketplace, reading the same schema format, serving team definitions to internal deployers only. Enterprises that need private team distribution without publishing to a public marketplace.

Registry mirror / cache A local cache of the Envelope registry that speeds up install requests in latency-sensitive or air-gapped environments.

Search & recommendation tool A standalone search index over published Envelope team definitions, with richer filtering than the Envelope marketplace UI provides: filter by required secrets, target platform, agent count, category, pricing model.

What Envelope should not build

Most of the above. The value of an open standard is that the ecosystem builds tooling that Envelope benefits from without funding. Envelope's job is to publish and maintain a clean, stable schema with good documentation, and to make the canonical registry the obvious destination for publishing and deploying.

The things Envelope should build directly are the ones where quality and trust matter at the foundation:

@envelope/schema — the JSON Schema file and TypeScript types
@envelope/cli — envelope validate and envelope publish
@envelope/conform — the conformance test suite for runtime implementers
schema.openenvelope.org — the documentation site for the schema

Everything else is ecosystem. The goal is to make building on the schema easy enough that developers do it without being asked.