Reference architectures, protocols, standards, and technologies for the emerging Agentic Web.
The web is evolving from a network of pages and APIs into a network of intelligent agents that can discover services, authenticate, communicate, delegate tasks, access tools, retrieve knowledge, and collaborate across organizational boundaries.
This project provides a documentation-first reference architecture for the Agentic Web Stack plus a deterministic local demo. It demonstrates how modern AI agents can be exposed, discovered, integrated, and operated using open standards and emerging protocols.
The goal is not to promote a specific vendor or framework, but to provide a clear and reproducible architecture that developers can use as a starting point for building agent-native systems.
This repository is documentation-first. The canonical project knowledge base lives in docs and is published as a VitePress site.
npm install
npm run docs:devUse the documentation site for architecture notes, technology stack levels, topic goals, standards, protocol references, papers, glossary terms, and runnable demo guidance.
Start with:
- End-to-End Demo
- Run the Local Demo
- Technology Stack
- Specifications
- Security and Trust
- Agent Card
- Agent2Agent
- Model Context Protocol
- Glossary
docs/ Canonical documentation and VitePress site
specs/ Machine-readable specs, schemas, discovery documents, and API definitions
services/ Local FastAPI demo plus future backend, MCP, and A2A services
agents/ Future research, coding, and enterprise agent implementations
examples/ Runnable end-to-end examples and workflows
infra/ Future local orchestration, deployment, and infrastructure assets
The runnable demo is a deterministic Literature Review Assistant. It exposes Agent Card discovery, local JWT access, OpenAPI REST endpoints, MCP-shaped tools, an A2A-shaped delegation endpoint, document retrieval, and review draft creation.
Prerequisites:
- Node.js 18 or newer
- npm
- Python 3.12 or newer
- uv
Install and test:
npm install
npm run api:sync
npm run demo:doctor
npm run api:test
npm run demo:smokeStart the API:
npm run api:devIn another terminal, run the workflow:
npm run demo:runThe API accepts and returns X-Trace-Id headers. Local debug endpoints are available at /debug/runtime and /debug/audit-events with the debug:read dev-token scope.
The Agentic Web extends the traditional web with autonomous and semi-autonomous AI agents capable of:
- Discovering services and other agents
- Understanding capabilities
- Accessing tools and APIs
- Authenticating securely
- Delegating tasks
- Retrieving and storing knowledge
- Collaborating with humans and other agents
Just as websites became accessible through browsers, Agentic Web services become accessible through AI agents.
Layer 7 Applications
Research Agents
Coding Agents
Enterprise Agents
Layer 6 Models
OpenAI
Gemini
Claude
Local LLMs
Layer 5 Memory
Vector Database
Knowledge Graph
Layer 4 Agent Protocols
MCP
A2A
Layer 3 APIs
REST
GraphQL
OpenAPI
Layer 2 Identity
OAuth2
OpenID Connect
Layer 1 Discovery
Agent Card
robots.txt
sitemap.xml
This repository contains documentation, validated demo specifications, and a local runnable demonstration platform consisting of the following components.
A traditional website exposing:
- Human-readable documentation
- Agent documentation
- OpenAPI specification
- Discovery endpoints
- Authentication examples
A modern backend exposing:
- REST APIs
- OpenAPI schema
- Local JWT authentication
- Tool endpoints
- Agent services
Machine-readable metadata describing:
- Agent identity
- Capabilities
- Available services
- Authentication requirements
- Supported protocols
Example:
{
"name": "Agentic Web Demo Agent",
"description": "Reference implementation agent",
"capabilities": [
"search",
"knowledge-retrieval",
"task-execution"
]
}The discovery layer allows agents to find services and understand capabilities.
Examples:
/.well-known/agent-card.json
/robots.txt
/sitemap.xml
/openapi.json
Future standards and experiments can be added as the ecosystem evolves.
Demonstrates secure authentication and authorization.
Technologies:
- OAuth2
- OpenID Connect
- JWT tokens
The goal is to show how agents can securely access protected resources while preserving user identity and permissions.
Provides multiple API styles commonly used in modern systems.
Traditional HTTP APIs.
Flexible query-based access.
Machine-readable API definitions enabling automatic tool discovery and integration.
Demonstrates:
- Tool exposure
- Resource exposure
- Agent-to-tool communication
Demonstrates:
- Agent discovery
- Capability exchange
- Task delegation
- Multi-agent workflows
Demonstrates long-term and semantic memory systems.
Examples:
- Chroma
- Qdrant
- Weaviate
Used for:
- RAG
- Semantic search
- Context retrieval
Structured entity relationships for reasoning and navigation.
Examples:
- Neo4j
- RDF
- Property graphs
Shows how different model providers can be integrated behind a common architecture.
Supported examples:
- OpenAI
- Gemini
- Claude
- Ollama
- llama.cpp
- vLLM
The architecture intentionally avoids vendor lock-in.
Example applications built on top of the stack.
Literature discovery, retrieval, summarization, and knowledge exploration.
Code generation, repository analysis, and development workflows.
Business process automation, data retrieval, and system integration.
- Explain the emerging Agentic Web architecture
- Provide practical reference implementations
- Demonstrate interoperability between standards
- Help developers build agent-native systems
- Remain vendor-neutral and standards-focused
This project is an evolving exploration of the Agentic Web ecosystem.
As standards such as MCP, A2A, Agent Cards, discovery mechanisms, identity frameworks, and memory architectures mature, this repository will continue to expand with new examples and reference implementations.
Contributions, discussions, and alternative architectures are welcome.