AdmissibleAI

Choose your integration surface. One runtime authority layer.

Use Admissible through OpenAI, LangChain, Direct SDK / Runtime, MCP Gateway, or Anthropic. Pick the surface that matches your stack and start with a concrete example.

All integration paths route through the same runtime authority layer.

OpenAI

Best for teams already using OpenAI tool calling.

Admissible evaluates tool requests before execution while preserving your existing OpenAI flow.

Open OpenAI quickstart

LangChain

Best for teams already building with wrapped tools and agent flows.

Admissible wraps LangChain tools so execution is evaluated before actions run.

Open LangChain quickstart

Direct SDK / Runtime

Best for teams that want the clearest runtime-level integration.

Use the SDK directly to evaluate execute and commit requests at the runtime boundary.

Open Direct SDK / Runtime quickstart

MCP Gateway

Experimental RC

Best for teams using MCP clients and MCP servers.

Route MCP tool calls through Admissible before execution, with commit admission for state-changing Tool Contracts.

Open MCP Gateway quickstart

Anthropic

Experimental

Best for teams using Claude client-side Tool Use.

Route Claude tool_use blocks through Admissible before tool_results are returned, with commit admission for durable tools.

Open Anthropic quickstart

Example previews

Each preview shows the integration surface. Open a quickstart for the fastest path, first run, and expected result.

OpenAI example

Admissible evaluates OpenAI tool requests before execution.

Example snippet

const client = createBaselineOpenAI({ baseline, openai, agentId, sessionId });const tool = defineBaselineTool({  name: "read.file",  authority: authorityPresets.readOnly,  execute: async () => ({ contents: "Admissible quickstart example" }),});await client.responses.create({ model: "gpt-4.1", input: "...", tools: [tool] });

Admissible evaluates the tool request before execution and keeps authority decisions on the same runtime path as the rest of the stack.

Minimal example

Use the short integration surface shown above to reach a first runtime decision fast.

Full docs

@admissible-ai/openai

Open quickstart

LangChain example

Wrapped LangChain tools are evaluated before they run.

Example snippet

const integration = createBaselineLangChain({ baseline, agentId, sessionId });const [readFile] = integration.wrapTools([  defineBaselineTool({ name: "read.file", authority: authorityPresets.readOnly, execute }),]);await readFile.invoke({ path: "README.md" });

Admissible wraps the LangChain tool surface once, then keeps execution checks and runtime decisions consistent across chained tool steps.

Minimal example

Use the short integration surface shown above to reach a first runtime decision fast.

Full docs

@admissible-ai/langchain

Open quickstart

Direct SDK / Runtime example

Direct requests are evaluated at the runtime boundary.

Example snippet

const client = new BaselineClient({ baseUrl, apiKey, userAgent: "admissible-sdk-quickstart" });const execute = await client.execute(createAllowedExecuteRequest(sessionId));await client.commit(createDeniedCommitRequest(sessionId, execute.operation.id), {  idempotencyKey: "idem_commit_001",});

Admissible evaluates execute and commit requests directly, which makes this the closest surface to the runtime authority layer.

Minimal example

Use the short integration surface shown above to reach a first runtime decision fast.

Full docs

@admissible-ai/sdk

Open quickstart

MCP Gateway example

MCP tool calls are governed before the underlying server receives them.

Example snippet

MCP client -> admissible-mcp serve  -> Tool Contract  -> /v2/execute  -> /v2/commit for state-changing tools  -> MCP server only after allow

Admissible sits between the MCP client and MCP server, resolves each tool to a Tool Contract, and forwards only calls that pass execute and commit admission.

Minimal example

Use the short integration surface shown above to reach a first runtime decision fast.

Full docs

@admissible-ai/mcp-gateway

Open quickstart

Anthropic example

Claude client-side tool_use blocks are governed before local tools run.

Example snippet

const client = createAdmissibleAnthropic({  anthropic,  admissible,  tools: [readReleaseStatus, sendCustomerEmail],});​const response = await client.messages.create({  model: "claude-sonnet-4-5",  messages,});

Admissible governs client-side Claude tool execution before application code runs, then returns Claude-compatible tool_result blocks for allowed, denied, deferred, modified, and failed calls.

Minimal example

Use the short integration surface shown above to reach a first runtime decision fast.

Full docs

@admissible-ai/anthropic

Open quickstart

Need runtime access? Create an account in Sandbox.

What stays the same. What changes.

The integration surface can stay familiar while the execution boundary gets stricter.

What stays the same

  • your model choice
  • your tool logic
  • your framework choice
  • your application flow

What changes

  • actions are evaluated before execution
  • execution passes through Admissible
  • runtime decisions become visible
  • authority is enforced at the execution boundary