The Control Paradigm Is Showing Its Age
Enterprise software architecture has operated on a simple assumption for decades: engineers specify behavior, machines execute deterministically. This model, rooted in Norbert Wiener's first-order cybernetics (1948), treats systems as passive tools under human control. It maps cleanly to imperative programming, centralized databases, and factory-style SDLC processes.
Large language models and autonomous agents break that contract. These systems don't execute instructions, they interpret stimuli and adjust behavior probabilistically. The failure modes shift from bugs and defects to drift and hallucination. Traditional change control doesn't address this.
What Structural Coupling Means in Practice
Niklas Luhmann's systems theory offers a more useful frame: complex systems are autopoietic, meaning self-referential and self-producing. An LLM doesn't "take orders" from a prompt, it processes input according to its internal weights and alignment training. Recent research on generative AI interactions describes this as structural coupling: the system maintains its own coherence while responding to environmental signals.
For architects, this means designing for alignment rather than control. Tools like Claude Code (2025) demonstrate the pattern: they observe context (codebase, terminal output, file system), adjust internal plans based on feedback, and re-align when they hit obstacles. This isn't command-and-obey, it's a homeostatic loop.
The Governance Gap
APAC regulated sectors face a specific challenge here. Financial services, manufacturing, and government systems must document which components operate deterministically versus probabilistically. Testing strategies, evidence requirements, and compliance frameworks differ fundamentally between the two.
The hybrid model requires continuous monitoring over traditional change gates. Accountability shifts from developer liability to licensed oversight with guardrails. This isn't a philosophical exercise, it's a compliance requirement as these systems reach production.
The Pattern: Stability Over Control
The practical architecture move is toward what Karl Friston calls minimizing surprise: systems that evaluate their own alignment with goals and self-correct. Instead of retry loops that fix JSON syntax errors, you need orchestrators that detect when retrieved information creates tension with user intent.
This doesn't mean abandoning deterministic systems. Most enterprise infrastructure will remain control-based. The question is how to build the interface layer where probabilistic and deterministic systems couple.
What This Means for CTOs
Three things to watch:
Audit requirements will diverge: Regulators are starting to distinguish between deterministic and probabilistic system components. Document your architecture accordingly.
Testing strategies need rewrites: You can't unit-test an LLM the way you unit-test a function. The industry is still figuring out what replaces it.
Vendor claims need scrutiny: "AI-powered" doesn't tell you whether a system is genuinely autonomous or just wrapping API calls in marketing copy. Ask about the feedback loops.
The shift from control to coupling isn't ideological. It's architectural necessity driven by how these systems actually behave. The teams that adapt their governance models first will ship more reliably.