\section{Discussion and Conclusion}\label{sec:conclusion}

\subsection{What the Correspondence Provides}

The mapping between externalization pillars and the Architecture triple is not a metaphor---it is a formal correspondence with executable implementation and verified properties. Concretely, it provides:

\begin{enumerate}[leftmargin=*]
\item \textbf{A language for harness design}: Instead of ad~hoc descriptions (``add a safety check''), engineers can specify certificates in $\mathrm{Know}$ with verifiable semantics.
\item \textbf{Preservation guarantees}: When compiling a harness to a different framework, functor-law checks are paired with explicit certificate identity and replay checks. This is mechanically verified for three supported certificate types across five targets.
\item \textbf{Composition rules}: The operad defines how skills combine (serial, parallel, trace) with type safety. Ma et al.'s empirical finding that atomic skills compose without interference is consistent with this closure-conditional structural view.
\item \textbf{Model parametricity}: Structural guarantees reside in $\mathrm{Know}$, not in a fixed model choice. The escalation experiment demonstrates this concretely for one task and two local models.
\end{enumerate}

\subsection{Limitations}

This work has several honest limitations:

\begin{itemize}[leftmargin=*]
\item \textbf{Static framework}: The Architecture triple is a snapshot. We do not model how harnesses evolve over time (e.g., learning from experience, adapting to distribution shift). Dynamic harness evolution is an open problem.
\item \textbf{Single reference implementation}: All validation uses one codebase (Operon). The correspondence needs independent implementations to confirm generality.
\item \textbf{Certificate scope}: Current certificates cover structural invariants (priority gating, convergence bounds) but not behavioral properties (``the agent never hallucinates''). Extending $\mathrm{Know}$ to behavioral certificates is future work.
\item \textbf{Escalation experiment scale}: The escalation experiment uses two models on one task. Scaling to diverse tasks and model families would strengthen the claim.
\item \textbf{SWE-bench-lite ceiling at 8B, confirmed cross-model}: Section~\ref{sec:swebench-phase2} reports 0 resolved instances across baseline, organism, and LangGraph on 10 SWE-bench-lite instances with Gemma~4 (8B / Q4\_K\_M), under a grounded rerun where each prompt contains the relevant files from the target repository at \texttt{base\_commit} and the model output is sanitized before submission. Section~\ref{sec:swebench-phase-c} reruns the same instances against a second locally-available 8B model (\texttt{deepseek-r1:8b}, DeepSeek-R1 distilled onto Qwen3-8B, Q4\_K\_M), with a format-correction retry loop active: when the sanitizer rejects, the runner re-prompts once with the specific reason code and the failed output embedded. Result: 0/30 evaluated, zero retry-recovered patches across all 30 submissions. Gemma4's one sanitizer-crossing instance (\texttt{django-11001} baseline, \texttt{unresolved}) was gemma4-specific; deepseek-r1 could not produce a \texttt{git apply}-clean diff for it either. The 8B-class format-discipline ceiling is not a single-model artifact, and retry-with-targeted-guidance is the wrong lever for a capability ceiling (it helps models that occasionally misformat, not models that cannot format at all). Consequently, our demonstrated transfer value in this paper is \emph{preservation} (Section~\ref{sec:preservation}) and \emph{primitive reuse} (the escalation experiment); task-resolution gains on SWE-bench-lite require a substantially stronger model, outside this paper's local-only scope.
\end{itemize}

\subsection{Conclusion}

Harness engineering is not ad~hoc---it has a categorical formalization. The Architecture triple $(G, \mathrm{Know}, \Phi)$ from the ArchAgents framework is the formal theory behind the harness concept that the LangChain ecosystem has converged on empirically. Structural guarantees are $\mathrm{Know}$-level replay artifacts preserved in the tested compiler suite by explicit identity and verifier-replay checks. Atomic skills compose via the operad under closure conditions. The model is selected by $\Phi$; changing it changes the deployment map, while supported certificates remain tied to preserved hooks and parameters.

The practical implication: before building a harness, define its certificates. Before compiling to a new framework, verify preservation. Before composing skills, check type compatibility. The categorical machinery provides the tools; the correspondence provides the vocabulary.

\paragraph{Availability.} The reference implementation is open source at \url{https://github.com/coredipper/operon} (\texttt{operon-ai} on PyPI, MIT license). The five compiler functors, atomic skills catalog, and certificate framework are all included.
