According to Gartner, over 40% of agentic AI projects will be canceled by end of 20271. Not because of dramatic technical failures, but because of unnecessary complexity. Framework layers, abstraction levels, orchestration mechanisms, each individually reasonable, but together creating a system more complex than the problem they are trying to solve.
This is not a new problem. In the 1960s, American engineer Clarence Leonard (Kelly) Johnson identified the same issue in military aircraft design.
KISS: Keep It Simple
KISS (Keep It Simple, Stupid) is a design principle stating that the simplest and most straightforward solution should be preferred when addressing a problem. While working at Lockheed’s Skunk Works division, Kelly Johnson based his approach on the premise that a fighter jet must be repairable in field conditions with a limited set of tools. The more complex the solution, the lower the probability of it being applied under field conditions2.
In the 12th chapter of Biographic Memoirs, Johnson’s approach is summarized as follows: “To produce practical, cost-effective, early, and better solutions to tough problems. Minimize reports and other documentation. Keep it simple, stupid, constantly reminds us of our approach”3.
The statement attributed to Albert Einstein, “Everything should be made as simple as possible, but not simpler,” draws the same boundary45. Simplicity does not mean inadequacy. Simplicity means the conscious absence of unnecessary complexity.
What Simplicity Is and Is Not
When addressing a problem, sophisticated solutions are often proposed first. KISS rejects this. The most intelligent approach is expressing a complex idea in a way everyone can understand.
Design and software processes tend to expand and grow more complex over time. The more sophisticated the solutions produced, the greater the additional cost (time, money, motivation) required to implement them. We can only be part of processes we understand. When a system operates more simply, errors that arise remain manageable.
Therefore, simplicity is not passive but an active choice. Complexity is the default; simplicity is a conscious engineering decision.
The Overengineering Trap in the AI Agent Ecosystem
The AI agent ecosystem is exactly at the point Johnson warned about. Frameworks add unnecessary layers: decorators, annotations, boilerplate. Approaches like KISS AI push back: agents as plain functions, orchestration as Python function composition, tools as ordinary callables. No ceremony6.
This is not just a matter of preference; data supports it too. The Agentless approach solves software problems through a simple two-phase process instead of complex autonomous agents7:
- Localization: Hierarchically find the fault at file, class, and function level
- Repair: Generate candidate patches in diff format at found locations
Result: 32% success rate on SWE-bench Lite (96 fixes), surpassing open-source agent systems at $0.70 per issue. More striking: GPT-4o with the SWE-Agent scaffold achieves 23%, but with the Agentless scaffold achieves 33.2%7. Same model, better results with the simpler approach.
Teams that have shipped over 14 products confirm this finding: the most successful implementations are not those with the most sophisticated AI architecture, but those where the right level of complexity was chosen for the problem.
KISS Practices in AI Development
Selective Intelligence
Deterministic handlers solve the majority of cases. LLM engages only for remaining edge cases, with much narrower scope8. This pattern is the most direct application of KISS in AI architecture: instead of feeding everything to the LLM, identify the points where the LLM is truly needed.
Single-Responsibility Agents
Each agent does one job. This is directly connected to the SoC principle: when you separate responsibilities, each part stays simple on its own. The production-grade agentic AI guide defines this as one of 9 core best practices: single-tool, single-responsibility agents8.
Tool-First Design
Define the tool first, then design the agent. When tools have specific and narrow scope, the agent’s decision burden decreases. The context engineering ecosystem extends this approach to context layers: instead of giving the agent everything upfront, provide JIT (just-in-time) search so it accesses information when needed.
Conscious Simplicity Decisions
Decision Gate establishes a conscious acceptance mechanism instead of “Accept All” in vibe coding. Making each acceptance decision conscious and systematic rather than automatically accepting every suggestion is a KISS application: a simple but disciplined process instead of complex automation.
When the Forge pipeline was being designed, event-driven architecture was proposed and consciously rejected. Why? A sequential pipeline is sufficient; over-engineering is unnecessary. In a solo developer context, event-driven orchestration creates a system more complex than the problem it is trying to solve.
KISS Violations and Their Cost
The cost of complexity is tangible and measurable.
Silent accumulation. LLM hallucinations cost businesses over $67 billion in 2024. Not from dramatic collapses, but from the silent accumulation of wrong answers, eroding trust, and abandoned projects nobody noticed in time. In complex systems, detecting these silent errors is even harder.
Context rot. Complex instruction files lead to instruction attenuation, one of the LLM behavioral failure modes. The agent progressively follows instructions less as the context window grows. The solution is simple: keep instructions short and focused.
Per-layer simplicity. The 5-Layer Defense Model requires multiple layers, but each layer being simple in itself is what KISS demands. A complex guard system is no more secure than simple regex-based pattern matching. The guard’s 25 BLOCK patterns work with simple regex instead of a complex ML classifier, and it is reliable precisely because of this.
Conclusion
Kelly Johnson said “keep it simple” for aircraft that needed to be repaired under combat conditions. In the age of AI agents, the same principle applies: systems that fail in production, experience context rot, and exceed cost estimates by 2x are most often systems that are not simple.
“Restraint is the most advanced engineering skill.” Complexity is cheap and easy; simplicity is rare and valuable.
Footnotes
- Gartner, “Over 40% of Agentic AI Projects Will Be Canceled by End of 2027” ↩
- Keep It Simple Stupid (KISS), Principles Wiki ↩
- Ben R. Rich: Clarence Leonard (Kelly) Johnson 1910-1990, Biographic Memoirs Volume 67, page 231 ↩
- Albert Einstein, Wikiquote ↩
- Everything Should Be Made as Simple as Possible, But Not Simpler, Quote Investigator ↩
- KISS AI: Keep it Simple, Stupid AI Agent Framework ↩
- Xia, C.S. et al. “Agentless: Demystifying LLM-based Software Engineering Agents”, 2024 ↩ ↩2
- A Practical Guide for Designing, Developing, and Deploying Production-Grade Agentic AI Workflows, 2025 ↩ ↩2
- 01 Kelly Johnson's KISS, defined in the 1960s, plays a more critical role in AI agent architecture than in classical software.
- 02 The Agentless approach (localization + repair) beats complex agent systems on SWE-bench. GPT-4o with same model: SWE-Agent 23%, Agentless 33.2%.
- 03 According to Gartner, over 40% of agentic AI projects will be canceled by end of 2027. Root cause: unnecessary complexity.
- 04 Selective intelligence: deterministic handlers for most cases, LLM only for edge cases. The narrower the scope, the higher the success rate.
- 05 Simplicity is not inadequacy but the conscious absence of unnecessary complexity. Restraint is the most advanced engineering skill.
+ How is the KISS principle applied in AI agent development?
Through three core practices: (1) Selective intelligence, where most cases are handled by deterministic handlers and LLM only engages for edge cases. (2) Single-responsibility agents, where each agent does one job and framework ceremony is rejected. (3) Tool-first design, where tools are defined first, then the agent is designed. Plain functions, Python composition, and ordinary callables are preferred over complex framework layers.
+ What is the Agentless approach and why can it be more effective than agents?
Agentless solves software problems through a simple two-phase process instead of complex autonomous agents: (1) Localization, hierarchically finding the fault at file, class, and function level, (2) Repair, generating candidate patches in diff format at found locations. It achieves 32% on SWE-bench Lite, surpassing open-source agent systems. GPT-4o with the SWE-Agent scaffold achieves 23%, but with the Agentless scaffold achieves 33.2%, same model, better results with the simpler approach.
+ How can overengineering be detected in AI projects?
Watch for three signals: (1) When framework layers become more complex than the problem the agent is trying to solve. (2) When an LLM is used where a deterministic solution would suffice. (3) When project costs exceed estimates by more than 50%. According to Gartner data, 85% of organizations misestimate AI costs by more than 10%.
+ How do KISS and SoC principles work together?
KISS says 'avoid unnecessary complexity', SoC says 'separate responsibilities'. They work together: when you separate responsibilities, each part stays simple on its own (KISS), and when boundaries between simple parts are clear, the system becomes controllable (SoC). In AI agent architecture, this dual principle means each layer simply solves a single concern.