Task Summary
A structured experiment in human–AI collaborative systems engineering: both a human architect and Claude Cowork independently applied classical function-to-form synthesis to the same UDG functional requirements, producing distinct but complementary physical designs.
The Universal Domain Graph (UDG) is the distributed hypergraph infrastructure at the core of the Spatial Web — storing all relationships between all Spatial Web Identifiers (SWIDs). Designing its physical deployment architecture requires decomposing a rich set of functional requirements into concrete software component nodes and the interfaces between them.
This project set the same challenge to two architects: apply systems engineering synthesis to derive a physical node architecture for the UDG from a common functional requirements specification. George Percivall, as a human expert architect and author of the requirements, produced a 6-node design. Claude Cowork independently performed the same synthesis and produced an 8-node design. The two designs were then compared.
The comparison reveals both convergence — on identity, registry, and the need for distributed graph storage — and divergence — in structural philosophy, treatment of client-side nodes, and the granularity of service decomposition.
Source Requirements
The functional requirements are drawn from the UDG System Design Specification, a document authored by George Percivall as part of the Spatial Web Framework (SWF) standards suite. The specification covers six functional domains: Knowledge Graph, Hyperspace, Registry, Social Network, Distributed Computing, and External Interface.
Design Method
Both designs used function-to-form synthesis: identifying functions, decomposing them, allocating them to physical forms (nodes), and defining inter-node interfaces. Both were constrained to the same requirements document.
Tool Used
The AI design was produced using Claude Cowork — an agentic desktop assistant built on the Claude AI model — which read the requirements document, conducted the synthesis autonomously, and produced a fully specified architecture design document.
Output
Both designs produced: a set of named software component nodes, functional allocations (function-to-node mapping), interface definitions, and node-level design requirements. The AI additionally produced a 68-requirement Word document with a complete functional allocation matrix.
Technical Context
Understanding the design challenge requires understanding where the UDG sits in the broader Spatial Web architecture defined by IEEE 2874-2025.
IEEE 2874-2025 — the Spatial Web Protocol, Architecture and Governance Standard — defines a comprehensive framework for a spatially-grounded internet in which AI agents, robots, IoT devices, and humans share a common model of the world. The standard defines the Hyperspace Modelling Language (HSML), the Hyperspace Transaction Protocol (HSTP), and Spatial Web Identifiers (SWIDs).
At the centre of this architecture sits the Universal Domain Graph (UDG) — defined as "a distributed hypergraph which contains all relationships between all known SWIDs in the Spatial Web." The UDG is simultaneously a knowledge graph of Spatial Web entities, a spatial atlas (hyperspace), a registry of registries for domain membership, a social network for agent communication, and a distributed computing system.
The UDG Functional Requirements Specification was authored by George Percivall as a preliminary design input for the SWF standards suite. It identifies these five conceptual views of the UDG:
The design synthesis task was to translate these five conceptual views into a physical deployment architecture of software component nodes and their interfaces.
UDG within the IEEE 2874-2025 Spatial Web Architecture
Systems Engineering Method
Both designs followed the classical systems engineering function-to-form mapping process, consistent with ISO/IEC/IEEE 15288 and the ISO/IEC/IEEE 42010 architecture description framework.
Function-to-form synthesis — also called functional allocation or requirements allocation — is the process of mapping what a system must do (functions) to what physical components will be responsible for doing it (forms). In software systems architecture, forms are software component nodes and their interfaces. The process is the core synthesis step in systems engineering and produces the logical and physical architecture of a system.
All functions the system must perform are identified and organized into functional groups. For the UDG this produced 31 functions in 6 groups: KG, HS, RG, SN, DC, and EX.
Each top-level function is decomposed into sub-functions as needed to expose sufficient detail for physical form assignment. Decomposition is limited to the level needed to differentiate distinct forms.
Each function is allocated to one or more physical component nodes using allocation principles: high cohesion (functions sharing state are co-located) and low coupling (loosely coupled functions are separated).
Data and control flows between component nodes are identified and named as interfaces. Requirements are derived for each interface from operational constraints in the specification.
Allocation Principles Applied: Both architects applied variants of the same underlying design heuristics — though with different emphasis. High cohesion: functions operating on the same primary data object should be co-located. Low coupling: functions with high data-exchange rates should be co-located; loosely-coupled functions should be separated. Separation of concerns: functions with distinct security domains or scalability profiles should be separated. Latency tiering: functions serving different latency tiers (agent-speed <1 ms vs. human-thinking 250 ms) may require distinct node types.
Figure 1 — Human Design
George Percivall's design uses an inheritance-based model: the SW Content Node is a base class containing all core daemons. Five specialized node types extend it by adding domain-specific modules.
Figure 1 — Percivall Human Design: Inheritance-based 6-node architecture. SW Content Node is the base class from which all specialized nodes extend.
Key Design Decisions
Inheritance hierarchy
Every node type extends the SW Content Node base class, which contains the core HSTP and HSML daemons, a domain graph, credential graph, and schema graph. Specialized nodes add modules rather than replacing functionality.
Client-side edge nodes
Agent Node and Thing Node are edge nodes — not infrastructure servers. They run on behalf of specific agents and IoT devices. This places agents and physical devices as first-class architectural citizens.
Integrated UDG Node
The UDG Node integrates graph database functions, hyperspace/Hyperworld services, and collective intelligence — distributing via sharding and replication as internal mechanisms rather than exposing them as separate node types.
Affiliation networks
Registry Nodes form affiliation networks — groups of nodes sharing common taxonomies and credentials. This creates a decentralized mesh architecture rather than a centralized hub topology.
Physical world presence
The Thing Node explicitly represents IoT sensors, actuators, and digital twins — acknowledging that the UDG must bridge the cyber-physical boundary. This concern is absent from the AI design.
Figure 2 — Claude Cowork Design
Claude's design uses a service-decomposition model: eight independently deployable nodes, each with a distinct functional responsibility, connected by nine named interfaces.
Key Design Decisions
Service decomposition
No inheritance hierarchy — each node is independently deployable. Functions are separated by cohesion and coupling analysis, producing dedicated nodes for storage, query, identity, registry, hyperspace, social networking, synchronization, and gateway.
Dedicated hyperspace node
Spatial embedding, H3/DGGS indexing, and hyperspace navigation are separated into a dedicated UDG-HN node. In the human design, these are modules within the UDG Node. Claude identified this as warranting separation due to distinct computational characteristics.
Explicit synchronization node
A dedicated UDG-SYNC node handles state propagation, HSTP routing, node discovery, and clock synchronization — concerns that are embedded as internal modules in the human design's UDG Node.
Infrastructure-centric
All 8 nodes are infrastructure servers. There are no edge or client-side node types. Agent and Thing functions are partially served by the UDG-SNN (Social-Network Node) and UDG-GTW, but without dedicated client-side node types.
Named interfaces
Nine named interfaces (I-HSTP, I-HSML, I-SPARQL, I-DID, I-VC, I-REST, I-H3, I-SYNC, I-AGENT) are explicitly specified with requirements. The human design relies on implicit HSTP messaging between all nodes.
Figure 2 — Claude Cowork AI Design: Service-decomposition 8-node architecture with 9 named interfaces. All nodes are infrastructure servers; no inheritance hierarchy.
Design Comparison
Where the two designs converge, diverge, and where each has gaps the other fills.
| Percivall Node | Claude Node(s) | Match | Key Differences |
|---|---|---|---|
| SW Content Node Base class: hstp.d, hsml.d, Domain Mgr, Graph Mgr, Agent Mgr, Cred Mgr |
UDG-GTW (partial) External API, protocol adaptation |
Partial | Percivall's SW Content Node is a base class that all other nodes extend. Claude has no base class concept — its GTW node only captures the external interface role. The daemon and graph management roles are distributed across UDG-GN, UDG-SYNC, and UDG-SNN. |
| UDG Node Distributed graph DB, Hyperworlds, collective intelligence, transformation pipeline |
UDG-GN + UDG-QN + UDG-SYNC + UDG-HN Four separate nodes |
Split | Claude decomposes what Percivall treats as one node into four separate concerns: graph storage (GN), query processing (QN), state synchronization (SYNC), and hyperspace operations (HN). Same functions covered, very different granularity. |
| Registry Node Domain register, SWID generator, VC issuance, affiliation networks |
UDG-RN Domain registration, VC issuance/verification, registry hierarchy |
Strong | Closest match between the two designs. Both cover domain registration, credential issuance, and registry hierarchy. Percivall additionally includes affiliation network credentialing — a concept absent from Claude's design. |
| DID Issuer SWID creation, did:swid method, alias resolution |
UDG-IDN SWID creation, DID resolution, VDR, aliases |
Strong | Second-closest match. Both designs agree this function warrants a dedicated node type. Claude additionally specifies the Verifiable Data Registry (VDR) and SWID Document structure. Percivall's version is specified more lightly. |
| Agent Node AGENT model/goals, SITUATIONS, social epistemology, social groups |
UDG-SNN (partial) Agent messaging, belief propagation, social norms, collective intelligence |
Partial | Fundamental difference in kind. Percivall's Agent Node is a client-side edge node running on behalf of a specific agent, persisting its model and goals. Claude's UDG-SNN is an infrastructure server handling messaging for all agents in aggregate. These are architecturally distinct. |
| Thing Node IoT sensors/actuators, observations, digital twins, cyber-physical |
(not present) | Gap | Claude's architecture has no equivalent of the Thing Node. IoT devices and physical sensors would implicitly connect through UDG-GTW, but there is no dedicated node type representing physical devices as first-class Spatial Web citizens with their own HSTP presence. |
| (not present) | UDG-HN Spatial embedding, H3/DGGS indexing, hyperspace navigation |
Gap | Percivall includes hyperspace as a module within the UDG Node. Claude separates it into a dedicated node, reasoning that spatial computation (vector embedding, H3 indexing at internet scale) has distinct performance and scaling characteristics. |
| (not present) | UDG-SYNC State propagation, HSTP routing, node discovery, clock sync |
Gap | Percivall treats state propagation and node discovery as internal mechanisms within the UDG Node (replication, the Collector module). Claude creates a dedicated coordination node, following a microservices separation-of-concerns principle. |
"The two designs agree on what functions must be performed; they disagree on how to package them. That disagreement is architecturally productive."— Design synthesis comparison, March 2026
Both designs cover the same functional requirements derived from the UDG specification. Neither design has a function that is entirely absent from the other — the difference is entirely in decomposition granularity, structural philosophy, and which concerns are treated as first-class node types versus internal modules.
The human design's 6-node count reflects integration: many concerns are grouped together under inheritance. The AI design's 8-node count reflects decomposition: concerns are separated for independent scaling and deployment.
A reconciled architecture would likely adopt Percivall's node taxonomy (including the critical Agent Node and Thing Node as edge-side types) while retaining Claude's finer-grained decomposition of the UDG Node interior (GN, QN, SYNC) as internal modules or deployment variants.
Design Process Observations
The comparison yields observations not just about the two designs, but about the nature of human and AI-assisted systems engineering design processes.
Structural Philosophy
The human architect chose an object-oriented inheritance model, likely reflecting years of experience with extensible software system design and an intuition that the SW Content Node daemon infrastructure is genuinely shared. The AI defaulted to service decomposition — a pattern prominent in cloud-native and microservices literature. Neither is wrong; they reflect different architectural traditions.
Physical World Awareness
The human architect — with deep experience in IoT, geospatial infrastructure, and cyber-physical systems — immediately recognized that physical devices (sensors, actuators, digital twins) require a dedicated node type. The AI, reasoning purely from text in the specification, did not give this the same prominence. Domain expertise surfaces requirements that text analysis alone may underweight.
Granularity Bias
The AI produced more nodes (8 vs. 6) by separating concerns that the human kept integrated. This may reflect the AI's training on decomposition-heavy software architecture literature, or a tendency to be exhaustive rather than pragmatic. Human architects typically balance functional purity against deployment complexity — a trade-off that requires operational experience to calibrate.
Documentation Quality
The AI produced a fully specified 68-requirement Word document with a complete functional allocation matrix in a single session. The human design document, while richer in conceptual depth, contained many "TBD" requirements sections. AI excels at transforming conceptual design into structured, requirements-traceable documentation — a time-consuming task for human architects.
Convergence
Both designs independently converged on dedicated nodes for identity (DID/SWID) and registry — and agreed that these warrant separation from general graph storage. This convergence on the same node types from independent synthesis processes provides informal validation that these are genuinely distinct architectural concerns that warrant their own node types.
Collaboration Model
The most productive outcome is not choosing one design over the other, but using both together. The human design provides architectural wisdom about client-side nodes and deployment philosophy; the AI design provides exhaustive functional coverage, explicit interface specifications, and formal requirements traceability. Together they constitute a more complete architecture than either alone.
Interested in the UDG, IEEE 2874-2025, or AI-assisted systems engineering design? Get in touch to discuss.
✉️ percivall@ieee.org