Universal Asset Taxonomy & Process Orchestration

Architectural Overview | Generated: 2026-03-20 | Scope: Full ecosystem metadata layer for autonomous workflow execution

Executive Summary

The AaaS ecosystem operates 4,380+ assets across 7 distinct types — skills, Cloud Functions, applications, directives, execution scripts, context files, and agents. Until now, none of these assets declared where they sit in the business lifecycle, what they consume, what they produce, or what triggers them.

This architectural addition introduces a machine-readable metadata layer that enables any supervisor agent to autonomously orchestrate workflows based on business logic — resolving dependency graphs, respecting human gates, and routing work through the correct domain-specific pipeline.

Business Domains

Named Processes

Assets Annotated

Human Gates

CLI Tools

Architecture: Three Pillars

Pillar 1: Universal `process:` Schema

A single metadata block added to any asset type. Lives in YAML frontmatter (skills, directives, agents), sidecar .process.yaml files (Cloud Functions, scripts), or package.json (apps).

process:
  domain: content              # Which business area
  lifecycle: build             # What kind of work
  inputs:
    - ref: "skill:scout-research"
      binding: required
  outputs:
    - ref: "app:blog"
      type: asset
  trigger:
    type: upstream
    source: "skill:scout-research"
  gate:
    type: review
    description: "Quality gate before publishing"
  cost_tier: standard
  estimated_duration: "20m"
  success_signal: "published items delivered"

Pillar 2: Asset Registry

A generated central index (registry/asset-registry.yaml) built by scanning distributed process: metadata across all asset sources. Truth lives at the source; the registry is a fast-queryable index.

Pillar 3: Process Orchestrator

A Python engine that reads the registry, builds directed acyclic graphs (DAGs), resolves triggers and gates, discovers downstream assets, and can execute process chains autonomously.

Business Domain Taxonomy

Every asset declares which domain it belongs to and which lifecycle stage it performs. The 7 domains map to distinct areas of business activity:

Domain	Description	Phases	Assets
Research	Intelligence gathering, market scanning, competitive analysis	`discover → analyze → synthesize → validate`	6
Content	Content creation from research to publication	`scout → intake → forge → digest → publish`	2
Sales	Lead generation, proposals, client activation	`prospect → qualify → propose → negotiate → activate`	0 (defined, not yet annotated)
Delivery	Agent execution, task processing, response delivery	`receive → route → execute → verify → deliver`	0 (functions not yet annotated)
Growth	SEO, social, email marketing, analytics, retention	`attract → engage → convert → retain → expand`	0 (functions not yet annotated)
Operations	Health monitoring, system maintenance, incident response	`monitor → alert → diagnose → remediate → report`	7
Infrastructure	Auth, hosting, database, functions, DNS, security	`provision → configure → deploy → validate → scale`	4

Orthogonal to domains, every asset also declares a lifecycle stage:

think → plan → build → verify → ship → operate

Named Process Chains (6 DAGs)

Process chains define ordered sequences of assets that form complete business workflows. The orchestrator reads these to build executable DAGs.

1. Research-to-Build Research

The 11-phase Universal Agentic Production Protocol. Minimum viable: Phases 1–3.

Goal Definition → Proposal Research → Strategy Routes → Requirements → Proposal → HUMAN GATE

Competitive Research & Industry Knowledge || parallel

→ Context Synthesis → Sub-Project Goals → Tool Selection

2. Content Pipeline Content

End-to-end content automation extracted from GravityClaw.

Scout → Intake → Forge → Digest → REVIEW → Publish

3. User Onboarding Growth

New user signup through context generation, email nurture, and account activation.

Signup →

Admin Alert & Context Pipeline || parallel

→ Welcome Email → Drip Sequence → Subscriber Bridge

4. GravityClaw Flow Content

Research agent to publication pipeline with quality gates.

Health Check → Entity Sync → Quality Review → REVIEW → Blog Entities

Daily Digest & Weekly Newsletter & Social Distribution || parallel

5. Agent Execution Delivery

Inbound request through agent processing to response delivery.

Inbound Email → Agent Executor → Retry (on failure) → Research Verify → REVIEW → Response Delivery

6. Autonomous Build Operations

The default operating mode for all non-trivial build tasks.

SCOPE → PLAN → SELF-REVIEW → REVIEW → EXECUTE → VERIFY → REPORT

Annotated Assets (19 of ~156 target)

Skills (10)

Asset	Domain	Lifecycle	Trigger	Gate	Cost
scout-research	Research	think	cron (daily 8am)	none	cheap
research-protocol	Research	think	manual	human_block	standard
content-pipeline	Content	build	upstream	review	standard
knowledge-graph	Research	build	upstream	none	cheap
context-engineering	Research	build	upstream	none	standard
prompt-library	Content	build	upstream	none	standard
youtube-digest	Research	think	manual	none	cheap
routing-llm	Infrastructure	operate	upstream	none	cheap
find-skills	Operations	plan	manual	none	cheap
security-engineer	Infrastructure	verify	upstream	review	standard

Directives (9)

Directive	Domain	Lifecycle	Gate
autonomous_build_protocol	Operations	plan	none
confirmation_gates	Operations	verify	none
delivery_reporting	Operations	ship	none
human_delegation	Operations	operate	human_block
model_routing_policy	Infrastructure	operate	none
production_protocol	Research	think	approval
security_protocol	Infrastructure	verify	review
skill_discovery	Operations	plan	none
system_awareness	Operations	plan	none

CLI Tooling

Registry Builder

python3 execution/build_registry.py --validate --verbose
# Scans skills, directives, function sidecars, script sidecars
# Validates enums and ref resolution
# Generates registry/asset-registry.yaml

Schema Validator

python3 execution/validate_process_metadata.py --all
# Validates all process: blocks against schema
# Checks domain, lifecycle, trigger, gate, cost_tier enums
# Verifies ref format (type:name)

Process Orchestrator & Query Engine

# Show a named process chain as execution plan
python3 execution/process_orchestrator.py --process content-pipeline

# ASCII visualization
python3 execution/process_orchestrator.py --process research-to-build --visualize

# Discover what runs downstream of an asset
python3 execution/process_orchestrator.py --after "skill:scout-research"

# Query by domain, lifecycle, trigger type
python3 execution/process_orchestrator.py --domain research
python3 execution/process_orchestrator.py --gates
python3 execution/process_orchestrator.py --cron

Remaining Work

Phase	Scope	Assets	Status
Phase 0	Schema, taxonomy, README	3 files	Complete
Phase 1	Named process chain definitions	6 DAGs	Complete
Phase 2a	Skills + directives annotation	19 assets	Complete
Phase 2b	Cloud Function sidecars	24 functions	Pending
Phase 2c	Execution script sidecars	6 scripts	Pending
Phase 3	Registry builder + validator	2 tools	Complete
Phase 4	Process orchestrator	1 engine	Complete
Phase 5	Vault bulk annotation	~4,224 skills	Future
Phase 6	AGENTS.MD + goals.md + directive	3 files	Future

Design Decisions

Decision	Chosen	Why
Metadata location	Hybrid (distributed + index)	Truth stays at source; index enables fast queries. Same pattern as npm/Kubernetes.
Functions metadata	Sidecar `.process.yaml`	Clean separation from TypeScript; independently parseable.
Registry scope	~156 active assets	Keeps YAML manageable; vault skills stay in Pinecone.
DAG vs Events	Both	Named processes = DAG; per-asset triggers = event-driven.
Taxonomy approach	Curated core + emergent	7 domains defined upfront; new ones added to `domains.yaml`.
Migration strategy	Phased (50 → 50 → 4,224)	Critical path first; vault bulk-inferred last.

Source Files

aaas-supervisor/
  registry/                          # Taxonomy system
    schema.yaml                      # process: block specification
    domains.yaml                     # 7 business domains + phases
    asset-registry.yaml              # AUTO-GENERATED central index
    processes/                       # Named process chains (6 DAGs)
      research-to-build.yaml
      content-pipeline.yaml
      user-onboarding.yaml
      gravityclaw-flow.yaml
      agent-execution.yaml
      autonomous-build.yaml
  execution/
    build_registry.py                # Scan + generate registry
    validate_process_metadata.py     # Schema validation
    process_orchestrator.py          # DAG engine + query CLI