LAI #137: Where AI Engineering Is Going in 2026

Good morning, AI enthusiasts!

Learning AI has changed dramatically over the past year. Building a working prototype is no longer the hard part. The challenge now is understanding the decisions behind it: what to build, how to structure it, where it should run, and how to make it reliable.

This week:

• Learn why persistent memory is becoming essential as coding agents tackle longer and more complex projects.

• See what happens when the cost of observability grows faster than your application and when self-hosting starts to make sense.

• Understand why agent memory needs governance, not just a larger vector database.

• Follow the same AWS agent built four different ways to see exactly what each layer of abstraction gives you.

• And if you’re working with Spark, learn how one memory management decision can make the difference between a failed job and a successful one.

Let’s get into it.

This week in What’s AI, I am walking through how I’d learn AI Engineering in 2026. You can open Codex, Claude Code, or Cursor today, describe an app in English, and get a convincing result in minutes. The agent can scaffold a RAG pipeline, add API routes, write tests, and prepare a deployment. That speed is genuinely useful. It is also one of the easiest ways to fool yourself while learning AI. When the first version is easy to generate, your value moves to the decisions around it. That is my idea behind AI engineering today. And I have put together the practical learning plan. Read the full article here or watch the video on YouTube.

When we built the “Research and Writing Agent with MCP” lesson for our Agent Engineering course, we ran into a deceptively simple evaluation question: which articles should the judge score?

The easy option was to ask another LLM to generate a batch of articles and use them as the test set. But those articles would never pass through the system we actually wanted to evaluate. The judge might measure writing quality, while missing failures in research, context transfer, or the handoff between agents.

So every evaluation example now follows the production path. We begin with the same brief a user would submit, run the research agent, pass its saved findings into the writing workflow, and score the final article.

This turns the output into a test of the entire system. If the research is weak, an important source is lost, or the writer receives incomplete context, the failure appears in the article, where the judge can detect it.

The takeaway: generate evaluation outputs with the workflow you plan to ship. Otherwise, you may be testing the quality of a substitute model rather than the reliability of your own system.

— Louis-François Bouchard, Towards AI Co-founder & Head of Community

Vardhan0902 has built Forefetch, a platform designed for a future where AI agents work more like teammates than assistants. Instead of tying long-running tasks to your laptop, Forefetch gives agents a persistent environment where they can keep working, maintain state across sessions, and finish jobs independently. As coding agents become capable of tackling increasingly complex projects, it’s an interesting glimpse at what an agent-first development workflow could look like. Check it out and share your feedback with the creator in the thread.

More than half of you still run long Claude Code or Codex tasks directly on your main machine. That makes sense for day-to-day work, but as agents start running for hours instead of minutes, your setup becomes just as important as the model you’re using. I’m curious whether this is simply the most convenient option today, or whether people have found that the trade-offs aren’t big enough to justify moving elsewhere.

I’d love to hear more about your setup. Do you usually have one agent running at a time, or several in parallel? What does your workflow look like, and what made you settle on your current environment? Let’s talk in the thread!

The Learn AI Together Discord community is flooded with collaboration opportunities. If you are excited to dive into applied AI, want a study partner, or even want to find a partner for your passion project, join the collaboration channel! Keep an eye on this section, too — we share cool opportunities every week!

1. Isaac_tigges built a local coding agent that brings reasoning and verification to compact open models and needs help with code quality & architecture review. If you think you can help, reach out to him in the thread!

2. Itsha123_45386 and their team are trying to develop an alternative to biometric authentication systems like Face ID and Touch ID/fingerprint sensors. They need some volunteers to help them collect data for their dataset. If you would like to contribute, connect with them in the thread!

Meme shared by jacekde

Persistent Memory for Claude Code on MongoDB Atlas

Long Claude Code sessions silently lose constraints when compaction drops tool outputs and summarizes earlier exchanges. This article builds a plugin that captures those statements into MongoDB Atlas before they vanish, using a PreCompact hook and two MCP tools. Retrieval runs entirely inside the database: Automated Embedding generates Voyage vectors, $rankFusion blends vector and keyword pipelines through reciprocal rank fusion, and a hosted reranker orders results.

1. I Self-Hosted Langfuse so My LLM Traces Would Stop Living On Someone Else’s Bill

Langfuse crossed 100K monthly traces and pushed managed pricing into painful territory, so the author self-hosted the open-source observability platform instead. Docker Compose spins up Postgres, ClickHouse, Redis, and MinIO in minutes, though production requires TLS, SSO, and eventually Kubernetes with externally managed dependencies. The article flags a notorious UTC timezone bug, treats Redis queue depth as the real health signal, and lays out honest cost math: self-hosting secures data control immediately, but only beats managed pricing at scale.

2. How Spark Manages Memory — The Unified Memory Model, Spills, and AQE

A daily 2.1TB aggregation job kept dying at 85% completion, and the author traced the failure to Spark’s Unified Memory Manager rather than raw heap size. This article walks through how execution memory always wins over storage in the borrowing contract, why protected cached blocks starved a skewed aggregation of room to grow, and how memoryOverhead, not executor.memory, killed the YARN container. Adaptive Query Execution’s skew-join splitting fixed the root problem, cutting cluster cost while pinpointing exactly which memory region overflowed.

3. Agent Memory Is the Real Moat

Agent memory becomes dangerous the moment it is treated as an unbounded vector store rather than a governed lifecycle. This article maps four distinct memory classes: working checkpoints, episodic outcomes, semantic facts, and procedural lessons, each with its own ownership and retention rules. Benchmarks from TraceRetain and LoCoMo show unbounded memory collapsing under noisy writes while selective retention holds steady. It closes with a practical adoption blueprint.

4. Road to Bedrock AgentCore, From a Single API Call to a Production Agent

Building the same weather-fetching agent four times across AWS’s tooling stack exposed exactly what separates each layer. This article implements the same core function on the Bedrock Converse API, Bedrock Agents, the Strands SDK, and AgentCore, keeping the logic identical to isolate each layer’s tradeoffs. Converse demands hand-written orchestration. Bedrock Agents hands the loop to AWS at the cost of visibility. Strands restores control with model portability. AgentCore deploys the same agent unchanged, adding Gateway, Memory, Identity, and Observability as managed infrastructure.

If you want to publish with Towards AI, check our guidelines and sign up. We will publish your work to our network if it meets our editorial policies and standards.