Lately, I have spent the first 1h each morning tinkering with agents, embeddings, RAG, multimodal RAG, LangChain, Haystack, etc (www.deeplearning.ai has amazing 1-2hrs courses. You can digest 1 each morning.)

The more I tinker with the technology, the more I see how agents can literally change the whole way we design and ship software.

If I’m to write a prod-ready software from scratch, there’s a completely new way to do it with Agents. It’s simply this:

Write agents with function calling, tools and MCP links.Thin CRUD layer on top of a storage layer (DB.)Let agents talk directly to that thin CRUD layer and between each others.

That’s it. No fixed application or business logic. Each agent will decide which tool/function to use on top of the CRUD layer of a DB. And when to call other agents for help outside their domain (expertise or content/knowledge area)

Taking a step back now.

For the last two decades, we’ve seen most software stack layers get abstracted, outsourced, or minimized. Frontends went from handcrafted jQuery to SPA to a React runtime. Infrastructure went from hand-rolled Chef scripts to serverless YAML.

Every software out there is built around a familiar three‑tier model:

Presentation (front‑end or API)Application / business logicData and storage layer

LLM‑powered agents collapse tiers 1 and 2 (and sometimes parts of 3) into a single reasoning layer. The agent decides what to show and what to call next from a list of tools (functions or other MCPs); the database becomes a very simple, schema‑enforced persistence tier. Think of it as serverless, except the function is intelligent.

Traditional applications center around deterministic business logic. Take:

if user.is_premium: apply_discount()

Logic is gated by feature flags, permissions, pricing tiers—each wrapped in code paths and tightly scoped unit tests.

Take customer support. What was once a flowchart of conditionals, database lookups, and email dispatching is now a retrieval-augmented agent querying embeddings, asking clarifying questions, and summarizing previous tickets.

Business logic used to be the “meat” of an application. Now, increasingly, it’s becoming scaffolding for agents.

A table can help us understand:

LayerCurrent (Old) WorldAgent-Powered StackUIHandcrafted and fixed forms and flowsThin prompt UIs, auto-generated (on-demand)Business LogicConditionals, services, pipelinesAutonomous agents with tools (on-demand, cached)Data LayerCRUD tightly coupled with services, Domain LogicThin CRUD interface on top of the storage layerDevOpsCI/CDStreamlined CI/CD: Lambda/Fargate, Vector DBs, MM RAG

Agents don’t need all the rigid business logic—only tools (APIs), memory and storage (DB), and context (retrieval). They decide how to use them, not you or me. Your app becomes a toolkit. The agent decides what hammer to use.

A shift from Logic to Language. The shift is epistemic. We’re moving from codified logic to language-driven reasoning. From state machines to semantics. From “how does this function work” to “what does the good outcome looks like?”

The agent doesn’t need to know every rule. It needs to know when to ask, where to look, and how to act.

This Changes Value Creation in Businesses. This enables something like this:

Instead of a 4-step wizard, lead with outcome. Describe what this flow should lead to. Let the agent deduce the rest.

The job of a product manager shifts from defining flows to defining outcomes. This also changes the engineer’s work from defining fixed rules to defining capabilities. The job of the engineer shifts from building guardrails to exposing tools (capability) safely.

Not everything will be agentified. Critical paths—like payment processing, identity verification, or compliance checks—still demand determinism. But increasingly, those become thin wrappers. The bulk of the experience, the thing that feels intelligent, adaptive, and helpful—will be the agent.

Final thoughts for a panicking industry. If you are an engineer interested in this, the only way to help us understand this shift is to tinker with it. Something you can do today is the following:

Identify a narrow self-contained slice in the codebase like a workflow (e.g., invoice approval).Expose CRUD endpoints (REST or GraphQL). Keep them boring.Wrap the endpoints in tools for your agent framework (Adept, AutoGen, LangChain, Haystack).Ship with a human‑in‑the‑loop review step; measure approval rates.Iterate: evolve guardrails, expand autonomy gradually.

I’m still tinkering with this around the edges and will have something more technical to share soon.