\section{Background}\label{sec:background}

\subsection{Agent Externalization}

Zhou et al.~\cite{zhou2026externalization} survey the shift from weights-based to harness-centric agent design. They identify four pillars of \emph{externalization}---the process by which cognitive burdens are moved from model parameters to external infrastructure:

\begin{enumerate}[leftmargin=*]
\item \textbf{Memory}: State across time. Session memory, vector stores, structured knowledge bases. The harness decides what persists, how it is retrieved, and when it expires.
\item \textbf{Skills}: Procedural expertise. Tool definitions, workflow templates, progressive skill loading. Skills encode \emph{what} the agent can do, independent of model capability.
\item \textbf{Protocols}: Interaction structure. Message formats, turn-taking rules, sub-agent delegation patterns. Protocols govern \emph{how} agents communicate.
\item \textbf{Harness Engineering}: The coordination layer itself. Prompt assembly, context management, compaction strategies, evaluation-driven refinement. The harness is the system that orchestrates memory, skills, and protocols into coherent agent behavior.
\end{enumerate}

Their key observation: ``agent infrastructure matters not merely because it adds auxiliary components, but because it transforms hard cognitive burdens into manageable forms.'' This transformation is exactly what formalization should capture.

\subsection{The ArchAgents Category}

De~los~Riscos, Corbacho, and Arbib~\cite{delosriscos2026categorical} introduce a category-theoretic framework for comparing agent architectures. An \textbf{Architecture} is a triple $A = (G_A, \mathrm{Know}_A, \Phi_A)$ where:

\begin{itemize}[leftmargin=*]
\item $G_A$ is the \textbf{syntactic wiring}---a graph of modules, ports, and directed edges describing how information flows.
\item $\mathrm{Know}_A$ is the \textbf{knowledge structure}---the set of structural properties, invariants, and certificates the architecture maintains.
\item $\Phi_A$ is the \textbf{deployment map}---the mapping between abstract capability slots and concrete model/tool implementations.
\end{itemize}

A \textbf{morphism} $f: A \to B$ is a structure-preserving translation: it maps modules in $G_A$ to modules in $G_B$, knowledge in $\mathrm{Know}_A$ to knowledge in $\mathrm{Know}_B$, and deployment maps in $\Phi_A$ to deployment maps in $\Phi_B$. In practice, a morphism is a \emph{compiler}---a function that transforms one agent architecture into another while preserving structural properties.

\textbf{Certificate preservation.} ArchAgents state certificate preservation as Proposition~5.1. In this paper we use the result operationally, not as a new proof: a compiler that claims preservation must carry each source certificate's theorem, parameters, and replayable evidence into the target $\mathrm{Know}$ structure. Functor laws alone are not sufficient for that claim, so our compiler checks certificate identity and verifier replay explicitly.

\subsection{Alternative Formalizations}

Liu~\cite{liu2026lambda} independently develops a typed lambda calculus ($\lambda_A$) for agent composition, extending the simply-typed lambda calculus with oracle calls, bounded fixpoints, probabilistic choice, and mutable environments. The work demonstrates that five mainstream frameworks (LangGraph, CrewAI, AutoGen, OpenAI SDK, Dify) embed as typed $\lambda_A$ fragments, and finds that 94.1\% of 835 real-world GitHub agent configurations are structurally incomplete under this formalization. Where $\lambda_A$ provides type-theoretic guarantees (type safety, termination), our categorical approach provides \emph{property preservation under compilation}---a complementary guarantee.

Willstr{\"o}m et al.~\cite{willstro2026nlah} propose Natural-Language Agent Harnesses (NLAH), externalizing harness behavior as portable, editable natural-language artifacts with explicit contracts. Their Intelligent Harness Runtime (IHR) executes these artifacts through durable contracts and lightweight adapters. This validates a key assumption of our work: that harnesses are portable objects with algebraic structure, not implementation-specific code. Our Architecture triple $(G, \mathrm{Know}, \Phi)$ provides the categorical formalization that NLAH's natural-language artifacts implicitly require.

Chen et al.~\cite{chen2026skilltester} introduce SkillTester, a comparative quality-assurance harness for agent skills that benchmarks both utility and security. Their rubric-based skill evaluation parallels our VerifierComponent, which scores stage outputs against task-specific rubrics and triggers model escalation when quality falls below threshold.

\subsection{Cross-Domain Corroboration}

Marom et al.~\cite{marom2026category} reach a structurally identical compositional-verification framework while solving a fundamentally different problem: translating biological mechanisms (a hygromorphic pinecone) into 4D-printed engineered systems. They define a category $\mathsf{Dyn}$ of stimulus-response dynamical systems with subcategories $\mathsf{Nat}\subset\mathsf{Dyn}$ (natural) and $\mathsf{Art}\subset\mathsf{Dyn}$ (artificial), an implementation functor $\mathcal{F}\colon\mathsf{Nat}\to\mathsf{Art}$, a specification space $\mathsf{Spec}$ with realization projection $\pi\colon\mathsf{Spec}\to\mathsf{Art}$, and a compilation functor $\mathcal{E}\colon\mathsf{Spec}\to\mathbf{Comp}$ translating verified specs to machine instructions. Their central theorem is closure of a simulation condition under composition---structurally the same preservation property we specify and check operationally in Section~\ref{sec:preservation} for the certificate-preserving morphisms of the ArchAgents category.

The relevance is not the materials substrate but the principle they articulate explicitly: \textit{``Two systems that share the same compositional structure \ldots can be related by a functor that preserves the interface logic at every scale without requiring that the two domains share any physical substrate.''} This substrate-independence is the materials-engineering articulation of the framework portability we claim for ArchAgents---a transformer-LLM agent and a Python LangGraph runtime share no more substrate than a cellulose pinecone and a polymer 4D bilayer, yet in both cases a structure-preserving functor relates them by interface logic alone. Their 2$\times$2 generativity demonstration, in which one of four printed designs (thermal twisting) arises purely by composition of components validated for other products, is independent, non-LLM, physically-fabricated evidence for the same compositional claim. We make no equivalence claim: their framework is substrate-validated through fabrication and measurement, ours is property-validated; only the compositional logic and the substrate-independence principle are shared.

\subsection{Enumerative and Categorical Views}\label{sec:enumerative-and-categorical}

Meng et al.~\cite{meng2026agentharness} present a contemporaneous engineering taxonomy, formalizing the harness as a six-component tuple $H = (E, T, C, S, L, V)$ for execution loop, tool registry, context manager, state store, lifecycle hooks, and evaluation interface, and surveying over 110 papers and 23 systems on a Harness Completeness Matrix. Among the nine open challenges they identify, their accompanying repository overview states: \textit{``Formal verification, portability testing, and protocol interoperability all require compositional reasoning that current research has not addressed.''}

This paper addresses that open challenge for one direction---certificate preservation under harness compilation---through the Architecture triple $(G, \mathrm{Know}, \Phi)$ and the structure-preserving morphisms of Section~\ref{sec:preservation}. The $(E, T, C, S, L, V)$ taxonomy refines the implementation surface of an ArchAgents object: $E$ and $T$ contribute wiring and realizations, $C$ and $S$ expose state, and $L$ and $V$ are the natural surfaces on which $\mathrm{Know}$-level certificates can be defined and replayed. A precise mapping between the two formalizations is developed elsewhere.

\subsection{The Gap}

These frameworks describe the same phenomenon from different angles. Zhou et al.\ provide the \emph{engineering} vocabulary (Memory, Skills, Protocols, Harness). De~los~Riscos et al.\ provide the \emph{mathematical} structure (objects, morphisms, functors). Liu provides \emph{type-theoretic} guarantees. Willstr{\"o}m et al.\ validate \emph{portability}. Meng et al.\ provide the \emph{enumerative} component taxonomy and explicitly mark compositional verification as open (Section~\ref{sec:enumerative-and-categorical}). None of these strands connect to the others. The result is that harness engineers build without formal guarantees, and theorists formalize without grounding in practice. This paper bridges the gap.
