OAK Becomes a Forest: From Repository to Movement

When we launched Open Agentic Knowledge (OAK) in early 2025, the idea was straightforward: build a public corpus of machine-readable knowledge that AI agents can use to operate software systems. We started with over 1,500 API specifications and workflow documents, making everything open source and building upon established standards to guarantee interoperability, portability, and longevity.

Since then, we've spoken with hundreds of developers, researchers, API vendors, and system architects across dozens of countries. These conversations have clarified something fundamental: OAK is not a product or a project. It is a movement.

Agents Need Knowledge, Not More Integrations

The missing ingredient for enabling agents to plan and execute actions reliably isn't more compute power or larger context windows. It is knowledge. Specifically, declarative knowledge: structured, detailed, machine-readable specifications of what actions are available, how to call them, and how to interpret their results.

The mathematics are simple. The breadth of documentation determines how many actions an agent can consider. The depth of documentation determines execution accuracy. Without this foundational knowledge layer, agents remain either severely limited in capability or fundamentally unreliable in execution, often both. We call this foundation the agentic knowledge layer, and we believe it must exist as a shared public good. Like other critical infrastructure, it will prosper as a shared resource, not trapped within proprietary walls.

From Single Repository to Distributed Network

We initially launched OAK as a centralized repository hosted by Jentic on GitHub. But the conversations with our community made it clear: this isn't about one company controlling a single resource. The agentic knowledge layer must evolve into a network of independently maintained but interoperable repositories, each contributing specialized coverage of the world's machine interfaces.

We need a forest of OAKs, not a single tree.

OAK must become a movement: A shared global effort to build open, declarative, AI-optimized knowledge for the agentic future. This distributed approach ensures no single point of failure, enables specialized expertise in different domains, and prevents any organization from becoming a bottleneck to progress.

Beyond Web APIs: The Full Spectrum of Machine Interfaces

We are also dramatically expanding our scope. Modern agents do far more than call web APIs. They execute command-line tools, generate single-use code that invokes SDKs, write and deploy configuration files, and increasingly interact with other agents through emerging protocols. OAK now aims to describe any machine interface an agent might encounter:

HTTP APIs

• REST, GraphQL, JSON-RPC, and asynchronous APIs
• Complete parameter schemas, authentication flows, and error handling

Command-Line Interfaces

• Bash, PowerShell, and Kubernetes tooling
• Parameter validation, output parsing, and execution contexts

Configuration Systems

• Infrastructure-as-code templates
• Application configuration schemas and deployment patterns

Agent-to-Agent Protocols

• A2A (Agent-to-Agent), ACP (Agent Communication Protocol)
• AGNTCY and other emerging standards for multi-agent coordination

In each case, we seek the most appropriate open standard schema to describe the interface comprehensively. OpenAPI excels for REST APIs, but we need equivalent precision for every interface type. Wherever an agent might need to act, declarative knowledge helps it understand available operations, required parameters, security models, error semantics, rate limits, and data governance policies, enabling reliable and often deterministic execution.

We anticipate that comprehensive workflow schemas will emerge for all types of structured interface documentation, not just REST. The Arazzo specification may eventually become the universal workflow description language, capable of orchestrating complex procedures across diverse API types and interface standards.

Anchored in Open Standards

To prevent ecosystem fragmentation and duplicated effort, OAK builds exclusively on existing open standards:

• OpenAPI (Linux Foundation) for HTTP API specifications
• Arazzo for procedural workflow descriptions
• Model Context Protocol (MCP) for runtime agent-tool binding

This foundation isn't exhaustive, what matters is selecting the right schema for each interface type and using it consistently. We expect to propose community-led extensions to these standards as agentic use cases reveal new requirements. Declarative, widely-accepted open standards ensure interoperability, portability, and longevity, allowing the entire ecosystem to invest confidently and achieve collective economies of scale.

Open Sourcing the Complete Pipeline

Generating high-quality agentic knowledge for the world's machine interfaces is an audacious goal. To accelerate community adoption and contribution, we are open sourcing the entire software pipeline we built to create the initial OAK corpus:

Data Processing Infrastructure

• Parsers and normalizers for OpenAPI specifications across different versions
• Linting and repair tools that fix common specification errors
• Enrichment systems that infer missing metadata

Intelligence Layer

• Authentication flow detection that identifies OAuth, API key, and custom auth patterns
• Rate limit inference from API documentation and behavior analysis
• Pricing tier mapping for cost-aware agent planning

Workflow Generation

• AI-powered synthesis of multi-step Arazzo workflows from API collections
• Dependency resolution for complex operation sequences
• Error handling patterns for robust workflow execution

Quality Assurance

• Evaluation scorecards measuring documentation completeness
• Agentic readiness scoring that identifies gaps in machine-readable specifications
• Version tracking systems that monitor upstream source evolution

We are releasing these tools so that others can contribute improvements, extend support to new domains, and operate independent pipelines for specialized knowledge areas.

Jentic Public APIs: One Tree in the Growing Forest

As part of this expansion, we're renaming our original repository to jentic-public-apis. This will be the first OAK repository of many, focused primarily on web APIs, enriched workflows, and content generated by our toolchain. We'll continue maintaining and growing this collection, but our goal is for it to become one tree in a much larger forest. Available at: jentic.com/github/apis

Discovery and Federation: Building the Network

A distributed network requires discoverability mechanisms. To seed this capability, we're proposing a simple convention: every OAK repository maintains an oak.csv file listing known sibling repositories. This enables cross-referencing between collections and allows both agents and indexing systems to traverse the entire network systematically. Example implementation: github.com/jentic/jentic-public-apis/blob/main/oak.csv

This federated approach ensures that as the network grows, agents can discover relevant knowledge repositories dynamically, without requiring centralized coordination or gatekeeping.

Enabling Just-In-Time Tooling Architecture

This data-driven approach to agent capabilities directly supports Just-In-Time Tooling (JITT) patterns. Instead of bloating agent context windows with comprehensive tool specifications upfront, agents retrieve precise, detailed knowledge exactly when needed during execution.

JITT enables several architectural advantages:

• Smaller, more general-purpose agents that aren't constrained by context limits
• Dynamic tool discovery based on current task requirements
• Richer tool specifications available at execution time
• Decoupling of tool knowledge from model weights and training data

In essence: tooling becomes a data problem, not a code problem. This shift fundamentally changes how we design and deploy agent systems.

The Time to Plant Is Now

The agentic future is arriving rapidly. Early enterprise deployments are moving beyond proof-of-concept into production systems that handle real business processes. If you share our conviction that agents require open, durable, interoperable tool knowledge, there are multiple ways to participate:

For API Vendors

Publish comprehensive declarative specifications for your APIs. If we've missed yours, let us know. We want complete ecosystem coverage.

For Developers

Build domain-specific OAK repositories for your areas of expertise. Use our existing collections and help us identify missing requirements for your use cases.

For Agent Platform Teams

Consider implementing JITT architectures and discuss integrating Jentic support for your users. We're happy to collaborate on technical integration patterns.

For Tool Builders

Contribute to our open-source pipeline tools or create specialized generators for new interface types we haven't covered yet.

For Researchers

Help us develop better scoring systems for API and workflow specifications. We need robust evaluation frameworks to direct community resources toward the most critical knowledge gaps.

A Durable Public Infrastructure Layer

The world is transitioning rapidly toward an era where AI agents will become ubiquitous across personal, SME, and enterprise software systems. The only sustainable foundation for this future is a richly populated, openly accessible knowledge layer that enables agents to interact safely and reliably with existing digital infrastructure.

With this evolution, OAK moves beyond being a single repository maintained by one company. It becomes a durable public infrastructure layer: decentralized, extensible, and community-owned. The technical infrastructure of the internet succeeded because it was built on open standards and shared resources. The agentic layer of computing deserves the same foundation.

The time to plant the forest is now.

Join us. Fork us. Extend us. Let's build the agentic knowledge layer together.

Ready to contribute? Start by exploring jentic-public-apis, reviewing our contribution guidelines, or joining our Discord community to discuss your ideas with other contributors.