Make your legacy APIs agent-ready.

From API to agent

1. Import your API. Supply a contract and its supporting files.
2. Review the operations. Inspect names, typed inputs, and behavior. Approve the operations agents may call.
3. Try a request. Preview a call, then test the generated tools against a mock.
4. Use the output. Choose the interface your agent or application needs.

The console follows the same flow. Run pnpm anvil console . --open after building. Start with Import API, then Review. Use API operations for request previews and Request builder for CLI and MCP drafts. Interfaces shows generated files and setup steps.

An API operation is one call imported from a specification. A bundle contains the API’s contracts, generated files, and review state. An interface is how an agent or application calls those operations.

Business actions is an optional, separate workflow for tasks that bind one or more API operations. It currently requires a project JSON with action definitions, source snapshots, and evaluation tasks.

Compile your first API

The payments example works locally without credentials. It includes a refund operation with confirmation and idempotency requirements you can inspect and test.

After installing from source:

pnpm anvil compile examples/payments/openapi.yaml \
  --manifest examples/payments/anvil.yaml \
  --service payments --out generated/payments
pnpm anvil status generated/payments
pnpm anvil inspect generated/payments

Run the full local quickstart to exercise the policy and test the generated MCP server against a mock.

What you can use afterward

Output	Consumer	Shared contract
Typed CLI	Developer or coding harness	Approved operations and validated arguments
MCP server	MCP client	The same operation and runtime policy
Four client SDKs	TypeScript, Python, Go, Java application	Generated operation methods and gates
Skill and hooks	Coding harness	Operation guidance and supported early refusals
Mocks and assurance records	CI or reviewer	Executable checks tied to the bundle hash
Gemini Enterprise connector kit	Gemini Enterprise app	MCP integration with explicit authentication and registration setup
Deployment inputs	Operator	Configuration and release plans

The Gemini Enterprise kit is generated separately after reviewing the bundle. Follow Connect Gemini Enterprise to generate, deploy, and register the connector.

The CLI and MCP runtime require installed or linked Anvil packages. The SDK trees can be vendored independently. SDK details.

Start from the material you have

Input	First step	What it produces
API description	anvil agentify	Candidate bundle, assessment, and capability proposals
Gateway export	anvil estate inventory	Gateway-aware inventory with provenance
Legacy deployment configuration	anvil legacy inventory	Offline evidence and technical candidates
Existing MCP server	anvil adopt	Review artifacts and an adoption plan

agentify stops for review. It does not infer approval or deploy. Legacy inventory does not generate or run a bridge. Parser support also differs from wire support: native gRPC requires a JSON transcoder; unsupported streaming and SOAP bindings are refused. Source support.

The model prevents interfaces from disagreeing

AIR, the Anvil Intermediate Representation, records schema, effect, risk, authentication, approval, confirmation, idempotency, retry, and evidence requirements. Every generated surface reads that model.

Condition	Result
Operation is unapproved	It is absent from callable surfaces
Required confirmation is missing	The call fails before execution
Idempotency is unproven	Automatic mutation retry is disabled
A harness hook is absent	Runtime policy still applies
Bundle bytes change	Previous assurance evidence becomes stale
publish succeeds	An operator plan exists; deployment has not occurred

The compiler cannot recover a missing business guarantee from an HTTP method. Supply supported semantics in the reviewed manifest.

Pick the next step

Goal	Guide
Compile and exercise one bundle locally	Quickstart
Resolve uncertain operations	Enrich and approve
Process a gateway export	Gateway import
Inventory middleware without an API description	Legacy inventory
Require fresh evidence before release	CI integration
Understand a refusal or incomplete bundle	Troubleshooting

Anvil is a source-installed toolchain for reviewed integrations. A small, single-client API wrapper may require less setup. Its value grows when several interfaces must preserve the same operation semantics.