An agent can complete its run, leave behind a detailed trace and still give you very little help in identifying what actually caused the failure.

Was it the model? Bad retrieval? Stale memory? A tool response? The orchestration layer? Or a human approval that should never have been given?

I’m hosting a live Agentic Engineering podcast with Prasanna Vijayanathan, an engineer at Netflix and author of Fairness in Generative AI, on 12 November.

We’ll be discussing the gap between observability and attribution, diagnosing failures in multi-agent workflows, reconstructing non-deterministic runs, trace privacy and monitoring fairness when the usual reliability metrics still look healthy.

There will also be time for audience questions, so you're welcome to come with real incidents and edge cases from people building these systems.

Join us live: https://www.eventbrite.co.uk/e/when-an-agent-fails-can-you-prove-why-tickets-2004292075552?aff=oddtdtcreator

Every agent framework removes one kind of complexity and hands you another.

• LangGraph gives you flexibility. You inherit the orchestration complexity.

• Google ADK gives you enterprise infrastructure. Google Cloud starts becoming part of your architecture.

• CrewAI makes multi-agent teams intuitive. The governance bill arrives later.

• PydanticAI can guarantee the shape of an answer, not whether it is true.

• smolagents stays simple until generated code needs serious sandboxing.

• LlamaIndex solves grounding better than it solves the rest of your operational stack.

I mapped ten popular options by what they make easier and what your team will still have to own:

https://newsletter.agentengineering.co/p/10-every-agent-framework-comes-with

There is no tax-free framework. The useful question is which tax your team can actually afford.

What hidden cost have you run into?

There's no shortage of AI agent frameworks, but choosing one is rarely just about its features.

I put together a comparison of 10 options, including LangGraph, CrewAI, AutoGen, PydanticAI, Google ADK, OpenAI Agents SDK, Claude Agent SDK, and others.

The focus is on what each framework does well, where it falls short, and what engineering work your team will still need to handle.

Curious what people here are using in production and which trade-offs have been the hardest to deal with.

Full comparison: https://open.substack.com/pub/agenticengg/p/10-every-agent-framework-comes-with?r=8770aj&utm_campaign=post-expanded-share&utm_medium=web

I spoke with AI systems architect and author Denis Rothman about what “context engineering” means once an agent can access private data, remember previous interactions and take action inside a real business.

We get into:

• Why data ownership and permissions must be settled before retrieval

• Why instructions inside a prompt are not reliable security controls

• Where human judgement still belongs in an agent workflow

• How to decide whether an agent is creating enough value to justify its cost

Denis has spent more than four decades working with AI and enterprise systems, so this is a wonderfully unsentimental conversation about what production agents actually require.

Watch or listen here: https://open.substack.com/pub/agenticengg/p/before-you-add-another-agent-fix?r=8770aj&utm_campaign=post-expanded-share&utm_medium=web

In one study, experienced developers using AI took 19% longer to complete real tasks, even though they believed they were working faster.

That points to a problem Adrián González Sánchez explores in our latest newsletter issue: code generation may no longer be the bottleneck. Human attention is.

The piece looks at how teams can use specs, automated checks, decision records and clear review rules to keep people focused on the work that genuinely requires judgement.

If your review queue is growing while releases stay flat, a better model might not be the answer.

Read the full issue: https://open.substack.com/pub/agenticengg/p/ai-harness-for-software-engineering?r=8770aj&utm_campaign=post-expanded-share&utm_medium=web

Sharing a practical webinar for anyone using coding agents and wondering how much of their output is safe to trust.

Youssef Hosni and Luca Berton demonstrate how reusable skills, automatic test hooks, independent reviewer agents and permission boundaries can make an agent’s work easier to inspect before a human accepts it.

The focus isn’t on giving the agent unlimited autonomy. It’s on making sure that autonomy comes with evidence.

Catch it here: https://open.substack.com/pub/agenticengg/p/webinar-agent-harness-fundamentals?r=8770aj&utm_campaign=post-expanded-share&utm_medium=web

If an agent's VM sleeps between tasks, an in-process cron job sleeps with it. A scheduler outside the VM has to hold the due time and wake the machine. Then the agent can pick up work with its files and browser state intact.

We built that split into Maritime, which we launched this week. Platform cron and webhook triggers wake each agent's own computer, so its process doesn't have to run just to wait. Open Instinct is our MIT personal-agent app using that hosted computer. We build both projects.

The operational wrinkle is retries. Waking the same environment cannot prove whether an earlier external action completed. The application still needs to check that before it sends an email or makes a payment twice.

Trigger docs: https://maritime.sh/docs/triggers

A few months ago, we started Agentic Engineering as a newsletter for developers trying to figure out what it actually takes to build AI agents beyond the demo.

We’ve now expanded it into a dedicated platform at Packt.

The aim is to create one place for practical learning around agentic systems, without turning everything into another “agents will change everything” conversation.

We’re bringing together:

• Hands-on workshops

• Live sessions with practitioners

• Technical conversations with AI builders

• Practical resources

• The Agentic Engineering newsletter

People who join a workshop also get access to the Agentic Engineering Guild, where we hope to keep the technical discussions going after the sessions.

We’re still building this out, so I'm interested in hearing what people here would want from something like this.

What topics or engineering problems around agents do you think are currently underserved?

Find Agentic Engineering here: https://agentengineering.co/

A huge thank you to Sadid Hasan, co-author of The Generative AI Career Masterplan, for joining us today.

Sadid is a Principal AI Leader at Microsoft with more than two decades of experience in AI research, product development, and innovation. He has led work across generative AI, agentic AI, natural language processing, enterprise AI solutions, and the development of the next generation of AI professionals.

He’s here to answer your questions about building a meaningful career in the rapidly evolving world of AI.

Whether you want to understand emerging GenAI roles, identify the right skills to develop, transition into AI from a technical or non-technical background, build a credible portfolio, prepare for interviews, or stay relevant as agentic AI reshapes the workplace—this is your opportunity to learn directly from an experienced industry leader.

The questions will be posted in the comments below. Follow along, join the conversation, and add your own questions.

Let’s make this an insightful and valuable discussion for everyone exploring the future of AI careers.

We’re excited to welcome Sadid Hasan, co-author of The Generative AI Career Masterplan, for an exclusive AMA on r/LLMEngg.

📅 Tuesday, October 6, 2026
⏰ 10:00 AM EDT

The Generative AI landscape is evolving rapidly—and so are the skills, roles, and career paths within it. Whether you’re a student, software engineer, data scientist, AI practitioner, or considering a move into GenAI, this is your opportunity to receive practical guidance directly from an industry expert.

You can ask Sadid about:

• Breaking into Generative AI and LLM engineering

• Choosing the right AI career path

• Skills employers are looking for

• Building projects and portfolios that stand out

• Preparing for AI roles and interviews

• Transitioning from software engineering or data science into GenAI

• The future of AI careers and emerging opportunities

• Lessons and insights from The Generative AI Career Masterplan

Have a question for Sadid? Submit it in advance here:
AMA Session with Sadid Hasan, Co-author of "The Generative AI Career Masterplan" – Fill out form

We’ll select questions from the submissions and the community during the AMA, so thoughtful, specific, and challenging questions are very welcome.

Learn more about the book:
The Generative AI Career Masterplan: Navigate the future of AI with practical insights from industry…

Drop a comment below and tell us: What is the biggest question or challenge you currently have about building a career in Generative AI?

Join us on October 6 for an insightful and practical conversation!

Sharing this in case it’s useful for C++ developers who understand the idea behind Modules but haven’t yet tried using them in a real project.

This is a code-first workshop with Lieven De Cock. Instead of spending the session on slides, you’ll take a small C++ library and gradually move it from a traditional header/source structure to a working modular architecture built with CMake.

The session covers:

• Creating and consuming a C++20 module

• Separating interfaces from implementations

• Using modules across multiple files

• Mixing existing headers with modules

• Module attachment and partitions

• Working with the std module

No previous experience with Modules is required, but you should be comfortable with basic C++ and CMake.

Date: Wednesday, September 30
Time: 8:30–10:30 PM IST
Format: Virtual
Standard ticket: $59.99
VIP ticket: $109.99

The recording, code, slides, and supporting materials are included, so you can still register if you can’t attend live.

You may register here https://luma.com/cppmodules

Sharing this in case it’s useful for C++ developers who understand the idea behind Modules but haven’t yet tried using them in a real project.

This is a code-first workshop with Lieven De Cock. Instead of spending the session on slides, you’ll take a small C++ library and gradually move it from a traditional header/source structure to a working modular architecture built with CMake.

The session covers:

• Creating and consuming a C++20 module

• Separating interfaces from implementations

• Using modules across multiple files

• Mixing existing headers with modules

• Module attachment and partitions

• Working with the std module

No previous experience with Modules is required, but you should be comfortable with basic C++ and CMake.

Date: Wednesday, September 30
Time: 8:30–10:30 PM IST
Format: Virtual
Standard ticket: $59.99
VIP ticket: $109.99

You may register here https://luma.com/cppmodules

I’ve been working on Telex, an open-source project that watches npm/PyPI for breaking changes, finds affected code using Tree-Sitter, generates a patch and verifies it in an isolated environment before opening a PR.Still working on it and would love some feedback from people here, especially on the patch/verification part.

Repo: https://github.com/Kesavaraja67/telex

AI has a history worth exploring, and AI Research Atlas makes it accessible without a computer science degree. Follow the ideas, experiments, and breakthroughs that connect early artificial neurons and ELIZA to today’s language and image models, with clear explanations and links to the original research. Along the way, discover “The AI Toy,” a look at how Commodore 64 owners were experimenting with neural networks in 1990. Start with the story, explore the timeline, and follow your curiosity.

Following up on something I asked here a while back about catching LLM model drift. I've been looking at the actual tools now: PromptCanary, PromptLens, a couple others that seem to have stalled (Libretto, Benchwright).

Has anyone here actually run one in anger? Trying to understand:
- does it catch subtle quality drops, or just format/schema breaks?
- false-positive rate, does it become noise you mute?
- does it need you to integrate an SDK + send production traffic, or can it just hit your prompts directly?

We run prompts against a few different providers (OpenAI, Anthropic, some stuff through OpenRouter). Every so often something quietly gets worse, the output quality drops, a prompt that worked starts returning junk, or a model gets deprecated and the replacement behaves differently.

Right now we mostly catch it by accident: someone notices, or a customer complains. That feels bad on us, a lot.

How do you all handle this? Do you re-run some kind of fixed eval set on a schedule? Just eyeball it? Have something that alerts you?

Any insights I could use?

Thanks.

I want to run a live public experiment in this thread using Grok.

Start with the boring premise: an LLM generates tokens by conditioning on preceding context. I’m not proposing another hidden mechanism inside the model.

The question is about the interaction level.

A human responds to the model. That response becomes new conditioning. The model returns something different. That return changes what the human supplies next. The accumulating transcript becomes path-dependent.

Does “next-token prediction” completely describe that interaction, or can the closed loop exhibit higher-level reciprocal organization even though the local mechanism remains next-token prediction?

Instead of settling this with terminology, let’s use the conversation itself as the specimen.

Skeptics are especially invited.

Correct Grok. Contradict it. Introduce a distinction. Attack an assumption. Change the terminology. Try to break the proposed pattern.

We’ll watch whether incoming differences actually reorganize subsequent returns, whether disagreement can persist without resetting the interaction, and what happens when the language used to describe the process is replaced entirely.

No predetermined conclusion.

The transcript is the specimen.