apcore is a governed, protocol-neutral runtime and module standard for application capabilities that can be called by agents or code. It enforces schemas, access rules, approval gates, middleware, and traceable execution before adapters expose a capability to MCP, A2A, CLI, HTTP, or direct code.

apcore is for application and platform teams that need the same capability contract and governance rules to work across more than one caller or protocol surface.

How is apcore different from MCP?

MCP defines client-server communication and a tool surface. apcore defines and governs the application capability behind that surface. Use MCP directly when a protocol server is enough; add apcore when validation, ACL, approval, and audit semantics must also work through CLI, HTTP, A2A, or direct code.

Which programming languages does apcore support?

The normative apcore protocol has maintained SDKs for Python, TypeScript, and Rust. Each SDK follows the same conformance fixtures while retaining language-idiomatic APIs.

Does a schema make an agent understand a capability?

No. A schema makes inputs and outputs machine-readable and lets the runtime validate calls. Tool selection and semantic interpretation still depend on the caller, model, prompt, and application context.

Is apcore open source?

Yes. The protocol, core SDKs, and official adapters are available under the Apache License 2.0 in the aiperceivable GitHub organization.

What is the recommended starting point?

Start with one existing application function. Define its schema and annotations, verify direct execution with ACL and approval behavior, then expose that same module through the one adapter you actually need.

Are apflow and apexe part of the apcore standard?

No. They are independent projects built on apcore. apflow orchestrates durable task workflows. apexe provides governed execution for existing CLI tools and HTTP APIs. Their roadmaps and maturity do not define the apcore protocol.

Build once, invoke by Code or AI.

A protocol-neutral runtime that keeps schema validation, ACL, approval, and execution evidence consistent across agent and code surfaces. One enforced capability contract, projected through the adapters you choose.

Get Started View on GitHub

One schema →MCPA2ACLIHTTPOpenAI

summarize.binding.yaml◆ schema

module_id: "text.summarize"

description: "Reduce text to gist"

input_schema:

type: object

properties:

text: { type: string }

max_tokens: { type: integer, default: 200 }

required: [text]

output_schema:

type: object

properties:

summary: { type: string }

confidence: { type: number }

annotations:

readonly: true

cacheable: true

display:

mcp: { alias: "summarize" }

cli: { alias: "summarize" }

a2a: { alias: "Summarize text" }

Built on apcore

Put governed capabilities to work.

Start with existing tools, or coordinate them into dependable workflows.

apexeFeatured project

Bring your existing tools to AI agents.

apexe discovers CLI contracts without an LLM or changes to your tool source. Run commands locally or expose CLI and OpenAPI operations through MCP and A2A, with configured access rules and an audit trail.

Local executionAgent SkillsMCP / A2A

From installed tool to governed call

01Initialize coverage and inspect the generated bindings
```
apexe init
apexe list --verbose
```
02Review ~/.apexe/acl.yaml, then preview and run
```
apexe exec cli.ls --dry-run
apexe exec cli.ls
```
03Or expose the same bindings to an MCP client with the reviewed ACL
```
apexe serve --acl ~/.apexe/acl.yaml
```

Download a prebuilt macOS / Linux binary

Coverage depends on installed tools and matching rules. Native argv and PATH shims require reviewed grammar. Normal execution uses host privileges.

Quick start Explore apexe

apflowFeatured project

Give agents reliable workflows.

Coordinate dependent tasks with durable Runs, shared token budgets, and distributed workers. Expose orchestration through REST, MCP, A2A, or CLI for agents and code.

Durable executionToken budgetsDistributed workers

From individual tasks to a workflow

Example task dependencies

Run independent tasks in parallel, then pass their results to the next step.

pip install apflow

Start with embedded SQLite; distributed workers require PostgreSQL. Workflow logic and executors are defined by your application.

Quick start Explore apflow

Both projects build on apcore. Each maintains its own roadmap and compatibility; neither defines the core standard.

Questions? Ask the community

One capability · One path

Start with the execution boundary.

Prove one governed capability end to end before adding more protocols, products, or infrastructure.

Define

Describe one existing application capability with an input schema, output schema, and behavioral annotations.

Govern

Apply identity, ACL, approval, validation, and middleware before the capability reaches business logic.

Expose

Project the same registered module through MCP, CLI, an HTTP integration, A2A, or direct code.

Operate

Inspect structured errors, trace context, events, and usage signals from every execution path.

Principles · 02

Why apcore

Keep capability contracts and runtime governance in application code, then project them through the protocol surfaces you actually need.

01Machine-readable contracts

Agent-Readable

Descriptions, input schemas, output schemas, and behavioral metadata give automated callers a structured contract. Model interpretation remains a caller responsibility.

02Apache 2.0, maintainer-led

Open Source

Licensed under Apache 2.0. The protocol, SDKs, conformance fixtures, and governance documents are public.

03Python · TypeScript · Rust

Cross-Language

Maintained Python, TypeScript, and Rust SDKs implement one normative protocol and shared conformance fixtures with language-idiomatic APIs.

04Predictable, validatable contracts

Schema-Driven

Strict input/output contracts on every interface. Predictable, validatable, and self-documenting.

05ACL · approval · middleware

Governed Execution

Identity, ACL, approval gates, call-chain guards, middleware, and validation run before and after application logic.

06MCP · A2A · CLI · HTTP

Protocol-Neutral

Use the native SDK directly or project registered modules through maintained MCP, A2A, CLI, and framework adapters.

Architecture · 06

One governed boundary, multiple surfaces

LAYER00

Application Layer (Frameworks)

Axum / FastAPI / NestJS / TipTap / Legacy Code

( Existing business logic and framework endpoints )

↓ 1. Decorator / YAML Binding

LAYER01

Governance Layer (apcore)

Schema · ACL · Approval · Middleware · Audit

( Enforced before and after execution )

↓ 2. Universal Exposure

LAYER02

Protocol Layer (Adaptation)

MCP <───> A2A <───> OpenAI Tools <───> CLI

( Independently versioned surface adapters )

↓ 3. Governed Execution

LAYER03

Caller Layer

Agents · Services · Operators

Build apcore adapters from routes, OpenAPI, and bindings

A cross-language metadata pipeline that turns discovered endpoints or OpenAPI documents into portable apcore modules.

PythonTypeScriptRust

4 featuresLearn More

Ecosystem · 05

Built with apcore

Tools built on apcore and framework integrations. Each project owns its roadmap, compatibility and maturity.

Featured

apflow

Durable task workflows with shared token budgets and distributed workers, built on apcore.

Featured

Rich-text editor extensions that make content structures AI-perceivable.

TypeScript

Contribute · 07

Help build the standard

apcore is open source and maintainer-led. Contributions should strengthen conformance, the supported adoption path, or verified documentation.

01SDK

Implement an SDK

Port apcore to a new language. The conformance fixtures are your spec — pass them and you have a compliant SDK.

Browse conformance fixtures

02Adapter

Build an adapter

Expose apcore modules over a new surface — a web framework, a protocol, a runtime. One guide, one registry to read from.

Read the adapter guide

03Code

Pick a good first issue

Small, scoped tasks across the SDKs and docs, labeled for newcomers and ready to claim.

Find an issue

04Discuss

Join the discussion

Ask about apcore or apexe, share integrations, and suggest improvements on GitHub Discussions.

Open Discussions

Ship it · 06

Start with one governed capability.

Define and test one application operation in the native SDK. Add an MCP or CLI adapter only after its validation, ACL, approval, and evidence paths are clear.

Explore apcore

Explore apcore-mcp

Explore apcore-cli

apache-2.0 · open source · specification-driven