Designing Lightweight AI Agents for Edge Deployment

The Minimal Capability Design (MCD) framework developed in this thesis demonstrates that lightweight, prompt-driven, stateless agents can be both functional and robust within edge-constrained environments (Singh et al., 2023; Banbury et al., 2021). By deliberately avoiding unnecessary orchestration layers, persistent memory, and excessive toolchains, MCD agents remain interpretable, portable, and resilient—qualities often diminished in fully-featured, over-engineered architectures (Ribeiro et al., 2016; Schwartz et al., 2020). This concluding chapter summarizes the core contributions of this work, synthesizes the key findings from the validation process, and reflects on the broader implications for the future of edge-native artificial intelligence (Russell, 2019).

This thesis advances the field of edge-native AI agent design through three primary contributions (Hevner et al., 2004):

A Generalizable Design Philosophy:
MCD formalizes a constraint-first approach grounded in capability sufficiency rather than raw capacity maximization (Kahneman, 2011). It provides a structured methodology for designing agents where simplicity is a feature, not a limitation (Mitchell, 2019). The framework offers diagnostic heuristics (e.g., the Redundancy Index, Capability Plateau Detector) to systematically detect and prevent over-engineering during the design phase (Basili et al., 1994).

A Validated Minimal Agent Architecture:
The research implemented and stress-tested a minimal agent architecture in stateless, browser-based, quantized LLM simulations (Chapter 6), successfully replicating real-world constraints while avoiding hardware noise (Venable et al., 2016). It then demonstrated the practical viability of this architecture through detailed walkthroughs in appointment booking, symbolic navigation, and prompt diagnostics (Chapter 7) (Patton, 2014).

Justified Optimization Scope:
This work critically evaluated multiple optimization strategies—quantization, pruning, distillation, and PEFT—before selecting quantization as the primary optimization axis (Dettmers et al., 2022; Nagel et al., 2021). The decision was driven not by exclusion, but by its compatibility with MCD’s stateless, zero-training, prompt-first architecture (Jacob et al., 2018). This rationale is woven throughout the framework (Ch. 4), validation (Ch. 6), and comparative analysis (Ch. 8).

A Pathway Toward Scalable Minimalism:
The framework is designed to be extensible to a wide range of edge applications, including IoT devices, field robotics, and embedded medical assistants, where tooling and memory are inherently constrained (Warden & Situnayake, 2019; Howard et al., 2017). It also supports a clear path forward for developing hybrid minimal agents (Chapter 9) that incorporate controlled extensions like ephemeral memory and on-demand tool use without sacrificing core principles.

The controlled simulations (Chapter 6) and applied walkthroughs (Chapter 7) yielded several key findings that validate the MCD approach:

Compact Prompts are Sufficient:
The simulations confirmed that compact, capability-focused prompts can achieve near-optimal results within strict token budgets, validating the principle of Bounded Rationality (Liu et al., 2023; Wei et al., 2022).

Statelessness is Viable:
Stateless fallback and recovery loops were shown to successfully sustain task completion even under degraded or ambiguous inputs, demonstrating the robustness of the Stateless Regeneration approach (Anthropic, 2024).

Failure Modes are Predictable:
The primary failure modes emerged in multi-turn semantic drift and over-compressed symbolic inputs, confirming that the most significant risks in MCD are related to context management, not a lack of capability (Amodei et al., 2016). Safe-failure behaviour (0% hallucinations vs 87% for verbose agents under overload) was verified in T7 stress tests. [Chapter 6]

Over-Engineering Reduces Performance:
The walkthroughs confirmed the Capability Plateau observations from the simulations (T6), showing that over-engineered prompts often waste tokens without improving accuracy (Strubell et al., 2019).

Optimization Scope Confirmed in Practice:
The simulations validated that quantized models (especially Q4 and Q8) could deliver predictable behavior under edge constraints without needing dynamic fine-tuning or toolchains, confirming the selection of quantization as the optimal first-tier MCD-compatible strategy. Future MCD implementations may also leverage domain-specific Small Language Models as base models, potentially achieving superior Q4 performance in specialized tasks while preserving architectural independence and stateless execution principles.

Across the ten-test simulation battery (T1-T10) and Walkthrough validation (W1-W3), MCD demonstrated substantial constraint-resilience advantages with a 2.1:1 reliability ratio under resource pressure conditions, maintaining ≥80% task completion (n=5 per variant; wide CIs acknowledged) task completion when alternative approaches degraded to 40-60% success rates under identical Q1 constraint scenarios. This performance differential represents a large effect size (Cohen's d ≈ 1.4-1.8 estimated across domains), with consistent cross-tier patterns (Q1/Q4/Q8) providing robust qualitative validation (Field, 2013).

10.2.5 Distinctive Contributions of the MCD Framework

MCD addresses a fundamental gap in current agent architectures: deployment under resource constraints (Bommasani et al., 2021). While existing frameworks optimize for cloud environments with abundant computational resources, MCD provides a systematic approach for scenarios where traditional architectures are not viable.

Architectural Differentiation
Constraint-native design approach. Unlike post-hoc optimization strategies that reduce existing frameworks, MCD employs design-time constraints as architectural principles (Gregor & Hevner, 2013). This represents a paradigm shift from "build complex, then optimize" to "build minimal, then validate sufficiency."

Empirical validation demonstrates this approach yields measurable advantages:

• 2.1:1 constraint-resilience advantage compared to verbose frameworks under Q1/Q4 resource pressure (T1-T10 validation)
• 2.6:1 token efficiency while maintaining task success rates (Chapter 6)
• Zero dangerous failures versus 87% hallucination rate in over-engineered systems under resource pressure (T7 analysis)

Deployment Context Differentiation
MCD targets deployment environments that existing frameworks cannot address:

• Resource-constrained platforms: ESP32 microcontrollers (4MB RAM), embedded medical devices, air-gapped systems, and browser-based applications with WebAssembly constraints.
• Safety-critical contexts: Applications requiring predictable failure modes and transparent limitation acknowledgment, where confident but incorrect responses pose operational risks.
• Cost-sensitive deployments: Scenarios where computational budgets, latency requirements, or power constraints make traditional agent stacks economically or technically infeasible.

Methodological Contributions
Diagnostic framework for over-engineering detection. MCD provides systematic tools for identifying capability plateaus and redundant architectural components—a capability absent in existing frameworks that assume "more complexity equals better performance."

Quantization-aware deployment tiers. The Q1/Q4/Q8 tiered approach enables dynamic capability matching to deployment constraints, supported by empirical validation across 375 test scenarios.

Validated safety advantages. Unlike frameworks that fail unpredictably under constraint, MCD demonstrates measurable safe degradation patterns, making it suitable for applications where failure transparency is essential.

Practical Significance
This work demonstrates that architectural minimalism can outperform complexity in constraint-bounded scenarios—a finding with implications for the growing edge AI market, IoT deployments, and privacy-conscious applications where traditional cloud-dependent frameworks are not viable solutions.

MCD reframes the concept of “lightweight” not as a capability limitation but as a strategic advantage for building resilient systems (Xu et al., 2023):

• Robustness: With fewer moving parts, MCD agents have fewer potential failure points, leading to more predictable behavior (Barocas et al., 2017).
• Explainability: The use of compact, interpretable prompts makes the agent’s reasoning transparent and auditable (Ribeiro et al., 2016).
• Portability: The stateless, tool-free logic allows MCD agents to be migrated across diverse platforms—browsers, mobile devices, and embedded systems—without major architectural rewrites (Haas et al., 2017).
• Safety-critical suitability: Validated low-risk failure patterns make MCD a candidate for medical triage and industrial inspection tasks. [Ch. 7]

These traits are critical for deployment scenarios where:
- Bandwidth and compute resources are scarce (e.g., offshore, rural, or embedded environments).
- Long-term maintenance costs must remain low (e.g., large-scale IoT deployments, robotics in the field).
- Operational transparency is non-negotiable (e.g., medical triage aids, safety-critical inspection agents).

While the MCD framework as presented is fully functional for a specific class of problems, it is not the final form of minimalism-driven agent design (Russell, 2019). As outlined in Chapter 9, several natural progressions for this research exist:

• Empirical Benchmarking on ARM-based edge hardware to validate the real-world latency, energy consumption, and drift patterns observed in simulation (Banbury et al., 2021).
• The development of Hybrid Minimal Agents that can selectively and ephemerally access tools or memory without breaking the core discipline of statelessness (Park et al., 2023). As hybrid architectures evolve, the future may also revisit pruning, distillation, and parameter-efficient tuning—but only in cases where they maintain stateless compatibility or are applied via ephemeral, non-training-dependent mechanisms.
• The creation of Self-Optimizing Minimal Agents capable of pruning their own reasoning chains via entropy-based scoring to prevent complexity creep during operation.
• Domain-Specialized MCD Integration leveraging SLMs as base models within MCD frameworks to achieve both architectural and model-level efficiency without compromising constraint-first design principles (Belcak et al., 2025).

MCD demonstrates clear architectural trade-offs that define its appropriate deployment contexts (Bommasani et al., 2021):

• Optimal-Condition Performance: Few-Shot and conversational approaches outperform MCD in resource-abundant scenarios where peak performance optimization takes precedence over constraint-resilience (Brown et al., 2020). MCD’s token overhead (31.0 avg) and higher latency (1724ms avg) make it suboptimal when resources are unconstrained.
• Constraint-Condition Advantage: MCD maintains higher reliability when resource pressure increases, achieving 85% performance retention under Q1 quantization compared to 40% retention for Few-Shot and 25% for conversational approaches.
• Design Philosophy Clarification: MCD optimizes for worst-case reliability rather than best-case performance, making it suited for edge deployment scenarios where resource availability is unpredictable or permanently constrained.
• Deployment Context Boundaries: MCD excels in scenarios where traditional approaches become non-viable due to resource limitations, but should not be chosen over optimized alternatives when computational resources are abundant and performance maximization is the primary objective.

This thesis introduced the Minimal Capability Design (MCD) framework to guide the development of lightweight AI agents for edge-constrained environments (Hevner et al., 2004). Through a synthesis of architectural literature, subsystem layering, and diagnostic heuristics, MCD reimagines agent design not as post-hoc compression but as minimality-by-default (Warden & Situnayake, 2019). The simulation experiments showed that MCD agents can withstand constrained execution with measured 80% baseline task-completion with superior constraint-resilience patterns, while the walkthroughs illustrated their applicability to domain-specific tasks without reliance on memory, toolchains, or orchestration (Patton, 2014).

The concurrent emergence of domain-specific Small Language Models validates the broader industry shift toward constraint-aware AI deployment, positioning MCD as both architecturally sound and strategically aligned with evolving model landscapes (Belcak et al., 2025).

While limitations remain—especially in tasks requiring persistent memory or high-context bandwidth—MCD offers a principled path toward deployable, interpretable, and fault-tolerant agents (Mitchell, 2019). As AI continues to shift toward real-world and edge use cases, frameworks like MCD will become essential (Russell, 2019). Their value lies not in outperforming generalist agents in unconstrained environments, but in enabling sufficiency under constraint. This work provides a repeatable, diagnosable, and extensible foundation for the next generation of edge-native AI systems that thrive not in spite of constraints—but because of them (Schwartz et al., 2020). The selection of quantization as MCD’s initial optimization axis illustrates this alignment in practice—enabling high compression, zero-dependency deployment, and architecture-consistent reasoning without introducing state or tool orchestration.

Component	Description	Validated Evidence
Core Problem	Over-engineering and resource abundance assumptions make most modern AI agents undeployable at the edge	T7 stress testing: 87% failure rate
Proposed Solution	The Minimal Capability Design (MCD) framework—a constraint-first methodology for designing stateless, prompt-driven, and robust agents	T1-T10: 2.1:1 reliability advantage under constraints
Key Findings	Minimalist agents are viable and robust for many edge tasks; over-engineering often reduces performance; stateless regeneration is practical	T6 plateau, T4 regeneration (96%)
Optimization Focus	Quantization selected as first-tier method due to alignment with stateless execution and deployment constraints	T10 tier validation: Q4 optimal
Primary Contribution	A formal, validated, and extensible design framework that enables interpretable and efficient AI agents for edge environments	W1-W3 domain applications
Architecture Design	Three-layer stateless agent template with fail-safe control loops and symbolic routing	T5 symbolic navigation, W2 success
Safety Validation	Safe failure modes with transparent limitation acknowledgment vs. confident incorrect responses	T7: 0% vs 87% hallucination rates
Efficiency Metrics	Token-efficient operation with measurable capability boundaries and predictable degradation patterns	T1-T3: 2.62:1 token efficiency
Deployment Context	Browser-WebAssembly validation as proxy for ARM-based edge device constraints and performance	T8: 430ms average latency baseline
Future Extensions	Hybrid architectures and hardware validation while preserving core minimalist principles	T4 context limits inform W1-W3 gaps
Model-Agnostic Design	Framework principles apply equally to general LLMs, quantized models, and domain-specific SLMs	Ch. 2, 4, 7, 8: SLM compatibility demonstrated

---

Appendices:

These appendices provide comprehensive supporting material that substantiates the core chapters of the work. They include detailed architectural diagrams, configuration settings, diagnostic heuristics, and empirical validation data related to the MCD framework and its deployment. Fully referenced from the main chapters, these appendices ensure clear traceability between theoretical concepts and experimental results.

• Appendix A for Chapter 6 Covers detailed prompt trace logs and performance measurements for Chapter 6 test suite of T1 to T10 tests. Consisting of simulation tests that probe MCD’s core principles under stress. Thereby testing the viability, robustness, and generalizability of MCD in constrained environments..

• Appendix A for Chapter 7 Consists of detailed prompt trace logs and performance measurements for Chapter 7’s domain-specific agent walkthroughs. It presents comparative evaluations of domain-specific agent workflows across various prompt engineering approaches under resource constraints.

• Appendix B Documents the configuration environment and experimental setup, including hardware specifications, model pools, memory and token budget parameters, validation frameworks, and reproducibility protocols crucial for the reliability of the study.

• Appendix C for Chapter 6 Comprehensive performance matrices for 10 validation tests (T1-T10) across three quantization tiers, documenting repeated trials methodology (n=5 per variant), 95% confidence intervals (Wilson score method), trial-by-trial execution traces, resource efficiency classifications, and deployment viability assessments for WebAssembly offline browser environments.

• Appendix D Presents layered architectural diagrams of the MCD agent system, detailing the prompt, control, execution, and fallback layers. This appendix visually links the subsystem designs and instantiated agent architecture, demonstrating how MCD principles enable effective stateless operation without complex orchestration.

• Appendix E Delivers a consolidated reference table of MCD heuristics and diagnostics, including capability plateau detection, memory fragility scores, semantic drift monitoring, and fallback loop complexity. It also outlines calibration evidence and practical implementation checklists for deploying minimal yet reliable AI agents.

• Appendix F This appendix provides detailed calculations supporting effect size claims throughout the thesis, addressing small sample size limitations (n=5 per variant) through emphasis on practical significance rather than inferential statistics.

• Appendix G Implementation guidance for the MCD Framework Decision Tree introduced in Section 8.7.2. Practitioners applying MCD principles to real-world deployment scenarios should consult this appendix for detailed decision logic, validation workflows, and empirically-derived thresholds from Chapters 4-7.

---

---

Software Link

---

Software Output for Chapter - 6 / .JSON files

---

Software Output for Chapter - 7 / .JSON files

---

The thesis is validated using the MCD Simulation Runner, a browser-based research framework that empirically tests resource-efficient large language model (LLM) deployment strategies. It runs standardized T1–T10 tests and domain-specific W1–W3 walkthroughs across multiple quantization tiers using WebGPU and WebLLM with live analytics and exportable results.

The framework operates entirely locally in modern browsers with GPU acceleration, ensuring privacy, reproducibility, and cross-platform consistency without server dependencies. Its interactive UI manages model loading, test execution, real-time detailed analysis, and result exports for comprehensive evaluation.

Key features include quantization-aware model management, semantic drift detection, multi-strategy domain validation, and strict reproducibility via cross-validation, and standardized hardware/browser setups documented in the appendices.

Key capabilities

• Runs comparative validation across Q1, Q4, and Q8 tiers with quantization-aware model management and live efficiency scoring.

• Provides always-visible detailed analysis, semantic fidelity and drift checks, and domain-specific metrics like slot extraction, navigation accuracy, and diagnostic precision.

• Exports structured datasets and summaries for reproducible analysis and appendix-style evidence linking to main chapter claims.

This validation software forms the empirical backbone of the thesis, enabling rigorous, reproducible benchmarking of constraint-resilient LLM designs in resource-limited environments. It provides critical infrastructure to support the thesis claims with quantitative, peer-reviewable evidence.

---

Data Source:

`MCD_Tests_Results_. json` (T1-T10)

'MCD_Walkthrough_Results_. json` (W1-W3)

Metrics derived from browser-based validation framework JSON outputs.
Complete test results available via thesis repository Downloads

All measurements include execution timestamps, model configurations, and environmental parameters for reproducibility.

---

References

---

PDF version of Thesis

---