For two decades, the default answer to most enterprise software questions was “buy.” Software-as-a-service made it easy to subscribe to best-of-breed tools, and building in-house was reserved for genuine differentiators. Agentic coding is now unsettling that default. In McKinsey’s State of AI in 2026 survey, 32% of respondents said their organization had skipped buying at least one software product or feature because it could build the capability in-house with agentic coding tools.
That is a striking number, and it raises a strategic question every CIO and CTO now faces: if the cost of writing code is falling fast, should the build-versus-buy line move? The answer is “yes, somewhat, and carefully.” Writing code was never the largest part of the cost of owning software. This guide separates what agentic coding genuinely changes from what it does not, and offers a decision model for 2026 portfolio choices.
What Agentic Coding Actually Changes
AI coding assistance has evolved quickly from autocomplete to agents that can plan a change, edit many files, run tests, read error messages and iterate. McKinsey’s 2026 survey reports that about two in ten respondents are scaling software coding agents, rising to 31% at larger enterprises. In practice, teams using these tools well report several shifts.
- Prototyping cost has collapsed. A working internal tool, data pipeline or integration can often be stood up in days rather than weeks, which makes it cheap to test whether a custom solution is viable before committing.
- Small, well-bounded applications are cheaper to build. Internal workflow tools, admin consoles, reporting apps and connectors with clear requirements are now realistic in-house projects for teams that previously lacked capacity.
- Modernization economics improve. Agents can help read legacy code, generate tests, translate between languages and document undocumented systems, which lowers the cost of replacing aging custom software.
- Customization of open-source and platforms is easier. Extending an open-source component or a low-code platform is less daunting when an agent can navigate unfamiliar codebases.
The modernization point deserves emphasis. Many organizations carry custom applications written a decade or more ago, often in frameworks that are no longer supported and by teams that have since left. Historically, the cost of understanding and rewriting these systems pushed companies toward replacing them with packaged software, even when the package fit poorly. Agents that can summarize code, map dependencies and generate characterization tests make it more practical to modernize in place or rebuild selectively, keeping proven business logic while moving to a supported stack.
These are real gains. They mean some purchases that made sense in 2022, particularly niche SaaS tools bought to fill small functional gaps, deserve a second look.
What Agentic Coding Does Not Change
The total cost of owning software is dominated by what happens after the first release. Agentic coding reduces some of these costs, but it does not remove them, and in some cases it increases them.
Ownership is forever
Every application you build must be hosted, patched, monitored, secured, upgraded and eventually retired. Dependencies age, security vulnerabilities appear, regulations change and the people who understood the original design move on. A vendor spreads these costs across many customers; an in-house team carries them alone.
Code volume can become a liability
When generating code is nearly free, organizations risk producing far more of it than they can review or maintain. Without strong engineering practices, AI-generated code can introduce duplicated logic, inconsistent patterns and security weaknesses at scale. The bottleneck shifts from writing to reviewing, testing and operating.
There is also a software supply chain dimension. Coding agents pull in libraries, suggest dependencies and sometimes reference packages that are outdated or poorly maintained. Each new dependency is something your team must track for vulnerabilities and license obligations. Organizations that build more must therefore invest more in software composition analysis, dependency policies and secure build pipelines, costs that rarely appear in the optimistic estimate that accompanies a quick prototype.
Domain depth and compliance still matter
Mature products in areas such as payroll, tax, ERP, core banking or regulatory reporting embed years of domain knowledge, edge cases and certifications. An agent can produce a convincing payroll calculator quickly; producing one that handles every jurisdiction, audit requirement and change in law is a very different undertaking.
Custom AI tools have a poor track record
The MIT NANDA initiative’s 2025 GenAI Divide report, as summarized by The Register, found that only about 5% of custom enterprise AI tools reached production, and that generic tools often outperformed specialized internal builds. The lesson is not that building is wrong, but that building well requires product management, data access, user adoption and sustained investment, not just code.
Agentic coding lowers the cost of writing software, not the cost of owning it. Move the build-versus-buy line only where your organization can also own the operation, security and evolution of what it builds.
Build, Buy or Compose: The Three Options in 2026
The binary framing of build versus buy is increasingly misleading. Most modern solutions are composed: a purchased platform at the core, configured and extended with custom components, connected through APIs and supplemented by AI agents. It helps to think in three options.
- Buy: subscribe to or license a complete product and adapt your processes to it. Best for commodity capabilities, heavily regulated domains and areas where vendors innovate faster than you could.
- Compose: use a platform (cloud services, a low-code environment, an ERP or CRM with an extension model, or open-source components) as the foundation and build the differentiating layer on top. This is where agentic coding adds the most value.
- Build: create and own the capability end to end. Best for genuine competitive differentiators, proprietary data advantages and processes no vendor serves well.
Gartner predicts that by 2028, 33% of enterprise software applications will include agentic AI. That means many purchased products will ship their own agents, which strengthens the case for composing around vendor platforms rather than rebuilding capabilities that vendors will soon offer natively.
A Decision Model: Eight Questions to Score
We recommend scoring every significant build-versus-buy decision against eight questions. Score each from 1 (favors buying) to 5 (favors building), and treat the total as a starting point for discussion rather than a mechanical answer.
- Differentiation: Does this capability create competitive advantage that customers would notice, or is it table stakes?
- Process uniqueness: Do you need to run this process differently from the industry standard, for good business reasons?
- Data advantage: Does the solution depend on proprietary data or tight integration with internal systems that vendors cannot easily access?
- Regulatory and domain complexity: Is the domain heavily regulated or full of edge cases that vendors already handle? (High complexity favors buying.)
- Rate of change: Will requirements change frequently in ways only you can anticipate, or will the market evolve faster than you can?
- Engineering maturity: Does your organization have the testing, security, observability and platform practices to own software safely at scale?
- Lifetime cost: Over five years, how does the fully loaded cost of building and operating compare with subscription, implementation and integration costs?
- Exit and lock-in: How painful would it be to leave a vendor, and conversely, how painful would it be to maintain an in-house system after the original team leaves?
Agentic coding mainly shifts the answer on question seven, and only for the build portion of lifetime cost. It does little for questions four, six and eight, which is why organizations with weak engineering foundations should be cautious about moving the line too far.
Calculating Lifetime Cost Honestly
Build cases fail most often because they compare the cost of building version one with the cost of a multi-year subscription. A fair comparison includes the following elements on both sides.
For building
- Initial development, including product management, design, architecture and testing, not just coding effort
- Hosting, environments, monitoring and incident response
- Security reviews, penetration testing, vulnerability management and dependency upgrades
- Ongoing enhancements, which commonly run for the full life of the application
- Model and agent costs for AI features, including evaluation and monitoring
- Knowledge retention: documentation, onboarding and the risk of key-person dependency
For buying
- Subscription or license fees, including expected price increases and usage-based components
- Implementation, configuration, data migration and integration
- Process change and training costs from adapting to the product
- Vendor management, contract renewal and the cost of eventual exit
- Gaps that still require custom work around the product
Agentic coding should be reflected realistically: it can reduce development effort meaningfully for well-specified work, but review, testing, integration and operations take a larger share of the remaining effort. A useful rule of thumb is to apply AI productivity assumptions only to the construction portion of the estimate, and to validate them with a time-boxed prototype rather than vendor claims.
Governance for an Era of Cheap Code
If building becomes easier, more teams will build. Without guardrails, organizations risk recreating the shadow IT problem at higher speed, with dozens of lightly governed internal apps touching sensitive data. A few controls keep the benefits while limiting the risks.
- A lightweight intake process that records what is being built, who owns it, what data it touches and how it will be supported
- Approved platforms and paved roads (templates, CI/CD pipelines, identity integration, logging) so that custom builds inherit security and observability by default
- Mandatory human review and automated security scanning for AI-generated code, with stricter review for code that handles customer data, payments or regulated processes
- Clear criteria for when a team-built tool must be adopted by a platform team or retired
- Periodic portfolio reviews to catch duplicated tools and orphaned applications
These controls also apply to vendor-supplied agents. As purchased products add autonomous features, IT leaders need to review what those agents can access and do, just as they would for in-house builds.
Using Build Capability to Reshape Vendor Relationships
One underappreciated effect of agentic coding is on negotiating power. When a credible in-house alternative exists, renewal conversations change. IT leaders do not need to build everything to benefit; they need a realistic option to build, backed by a prototype and a cost model.
The MIT NANDA authors observed that organizations getting value from AI vendors treated them more like business process outsourcing partners than software suppliers, demanding deep customization and holding them to business metrics. The same posture works for broader software sourcing in 2026:
- Ask vendors to price against outcomes or usage bands that match your actual consumption, rather than broad seat-based tiers
- Insist on open APIs, data export and extension points, so that your teams can compose around the product instead of waiting for the vendor roadmap
- Clarify how vendor-embedded agents use your data, what they can do autonomously and how their behavior is logged
- Negotiate exit terms, including data portability and transition support, before you need them
A sourcing strategy that combines selective building with tougher buying usually delivers more value than either extreme. The goal is not to replace vendors but to ensure every purchase earns its place in the portfolio.
A Worked Example: Replacing a Niche SaaS Tool
Consider a generic professional services firm paying for a niche SaaS tool that manages internal resource requests. The tool is used by a few hundred staff, integrates poorly with the firm’s HR and project systems, and its renewal price has risen. An engineering lead proposes rebuilding it in-house with agentic coding tools, estimating a few weeks of effort.
Scoring the decision clarifies the trade-offs. Differentiation is low, but process uniqueness and data advantage are moderate because the firm wants tighter integration with its own project data. Regulatory complexity is low. The firm has a cloud platform with standard pipelines and identity integration, so engineering maturity is reasonable. The lifetime cost comparison, once hosting, security, support and enhancements are added, still favors building, but by a smaller margin than the original estimate suggested.
The firm chooses a compose approach: it builds the application on its existing low-code and cloud platform, using agentic coding to accelerate development and test generation, and assigns a named product owner and a small platform team for ongoing support. A time-boxed prototype validates the effort estimate before the SaaS contract is canceled, and the new tool is added to the application inventory with a review date. Equally important, the firm decides not to rebuild its timesheet and billing system, which scored strongly toward buying because of domain complexity, integration with finance and audit requirements.
Outlook and Conclusion
Over the next few years, the economics of software will keep shifting. Vendors will embed agents into their products and adjust pricing toward usage and outcomes. Internal teams will gain more capable coding agents and better tools for testing and modernization. The organizations that benefit most will be those that update their sourcing strategy deliberately, rather than letting individual teams make one-off decisions based on how quickly a prototype came together.
The practical takeaways for IT leaders are straightforward. Revisit niche purchases where integration pain is high and domain complexity is low. Favor composing on strong platforms over building from scratch. Measure lifetime cost honestly and apply AI productivity gains only where they truly apply. And invest in the engineering foundations (paved roads, review practices, observability and ownership) that make building safe. Agentic coding is a powerful new option in the sourcing toolkit, not a reason to abandon discipline.
How Hanoi Technology Can Help
Hanoi Technology helps IT leaders make build, buy and compose decisions and delivers the engineering foundations and dedicated teams to execute them.