The Stack a Modern AI Strategy Actually Runs On

Most companies I work with spend more time picking tools than using them. The stack becomes the strategy. It shouldn't.

What follows is what's actually working across the companies I'm engaged with right now. Specific layers. Specific choices. No vendor ads.

The model layer

You need one primary model and a fallback. That's it.

Right now that means OpenAI (GPT-4o class) or Anthropic (Claude Sonnet class) as the primary, with the other as your fallback. Not because they're dramatically superior to everything else, but because they have the API reliability and context windows that production applications actually need.

The model isn't your strategy. It's a commodity getting cheaper every quarter. Make a pragmatic choice and move on.

The orchestration layer

This is where the real architecture decisions happen. Something needs to chain model calls, route between agents, manage retries, and handle what breaks at 2am.

LangChain is mature and getting better. LangGraph is worth understanding if you're building agents with state. n8n is genuinely excellent for teams that aren't primarily engineering organizations — I've watched non-technical product and ops teams ship real automations in weeks that would have taken months to build from scratch.

The right question isn't which orchestrator is best. It's: what does your team have the capacity to maintain six months from now?

The memory layer

This is what most companies underinvest in, and where most AI applications quietly fail.

The moment you want your application to know anything about the user across more than one session, you need memory. Options range from PostgreSQL with pgvector to full RAG pipelines to something like Mem0. Which one fits depends on how much structured vs. unstructured data you're working with.

Don't skip this because it's unglamorous. The demo works great with stateless models. The product needs memory to be useful. The right first use case almost always has a simple memory answer that teaches you exactly what you need before you scale it. I wrote about picking that first use case — the memory question is usually the one that makes the decision obvious.

The evaluation layer

Most companies don't have one. That's the tell.

If you can't measure whether your AI output is getting better or worse over time, you're flying blind. This doesn't require a sophisticated ML evaluation platform. It requires defining what "good" looks like for your specific output and checking it on a schedule.

LangSmith if you're in the LangChain ecosystem. Braintrust if you're not. Even a spreadsheet of human-reviewed outputs beats nothing, and it usually reveals patterns you'd never catch through casual testing.

Running the AI audit before you build and setting up evals before you ship puts you ahead of most companies I see in the field.

The infrastructure layer

Vercel for frontend. Modal or Fly.io for backend inference when you need something faster than standard cloud. Supabase for the database layer. This isn't a radical choice — it's just fast to iterate on and cheap enough to experiment with.

The thing companies consistently underestimate: token costs at scale. A feature that costs $0.02 per call seems fine until it's called 50,000 times a day. Run the math early. Before you ship, not after.

What the stack actually tells you

The companies shipping AI well aren't using different tools. They're making faster decisions about their tools.

Pick a model. Pick an orchestrator. Build a memory layer. Define your evals. Get something into production and let real usage teach you what to change.

The AI strategist's job isn't to find the perfect stack. It's to make the stack decision fast enough that your team starts learning from users instead of conference talks.