3 · Concept Ontology & Node Taxonomy

Top-level ontology (AgentMark v1.0 target) — the durable, vendor-neutral set of first-class concept families:

Actor          Capability      Knowledge       Tool
Protocol       Middleware      Workflow        Runtime
Harness        Memory          Policy          Infrastructure
Evaluation

Protocols are elevated to first-class citizens, because the AI stack is increasingly: Models -> Agents -> Protocols -> Tools (not just Models -> Tools).

[protocol: MCP]
[protocol: A2A]
[protocol: ACP]
[protocol: HTTP]
[protocol: Webhook]

Capability — the concept UML never had. A capability is not architecture and not implementation. It answers the questions people actually ask about an agent: "Can it browse? Can it write code? Can it access Salesforce?"

capability: Research
capability: Code
capability: Browse
capability: Purchase
capability: Execute SQL

Capabilities should also carry risk and requirements:

capability: write_files   { risk: medium,   requires: [policy: Repo Write Policy] }
capability: run_shell     { risk: high,     requires: [approval: User Approval] }
capability: send_email    { risk: high,     requires: [approval: Human Approval] }
capability: delete_data   { risk: critical, requires: [approval: Admin Approval] }

Stable node types (keep the grammar small, push detail into properties). The complete stable set:

human   ui      agent   model   prompt  skill   context memory  rag     embed
data    cache   tool    api     mcp     a2a     protocol middleware selector router
workflow runtime harness framework sdk    browser driver  desktop shell   fs
container vm     sandbox queue   event   policy  guardrail approval secret  auth
budget  eval    bench   metric  log     monitor claim   constraint decision

This single list covers MCP, A2A, direct APIs, RAG, n8n-style workflows, CrewAI-style multi-agent systems, middleware, tool selectors, harnesses, browsers, headless Chrome, Playwright, and evaluation. MCP is modeled as a protocol/server layer for connecting AI apps to external data sources, tools, and workflows. A2A is modeled separately from MCP: MCP is agent→tool/context integration; A2A is agent→agent interoperability.

Roles, not exploding agent types. Do NOT invent 50 node types. Instead, one agent type carries a roles property:

[agent: Coding Agent  {roles: [planner, executor, coder, tester]}]
[agent: Research Agent {roles: [searcher, retriever, summarizer]}]
[agent: Safety Agent  {roles: [critic, policy_judge, blocker]}]

Recommended role vocabulary:

frontdoor  router     planner    decomposer executor  tool_user browser
coder      tester     researcher retriever  summarizer synthesizer memory_curator
evaluator  critic     judge      verifier   red_team  supervisor manager
negotiator handoff_target monitor  repair     retry

Runtime family — define the confusing words precisely:

Type	Meaning	Examples
sdk	Library/API for building agent apps	OpenAI Agents SDK
framework	Opinionated construction model for agents	Google ADK, CrewAI
runtime	Execution engine: state, persistence, streaming, checkpoints	LangGraph
harness	End-user/backend agent environment: tools, permissions, filesystem, memory, loops	Claude Code, Codex CLI, Hermes
protocol	Wire/interface standard	MCP, A2A
driver	Low-level controller	Playwright, CDP
sandbox	Isolated execution boundary	Docker, Firecracker, browser sandbox

Context as a first-class runtime object:

[prompt: Hermes System Prompt] -> [context: Coding Context]
[skill: Repo Conventions]      -> [context: Coding Context]
[memory: User Preferences]     -> [context: Coding Context]
[rag: Repo Retriever]          -> [context: Coding Context]
[context: Coding Context]      -> [model: Codex]