Advancing AI Development

Of course you need to use open-source models if you’re an enterprise leader. Close model providers, that are now forcing data retention, are gaining immense leverage on your business if you don’t. As you connect models to your business context, they see it and learn from it, and have a track record of going after their most successful customers thanks to this information. But that’s not enough, you also need to store your data and records in open systems, or your software vendors might block you from building AI systems outside of the walled garden they have set up for you. If you can’t convince them to give you complete access to the data they manage for you, AI fortunately allows you to migrate quite fast. Once you’ve got hold of your data, you’ll need to manage how AI systems can access this data on behalf of human users, because you don’t always want Bob to see what Alice is doing in your company. That’s hard and merciless, since AI models are great at finding need-to-know errors. It takes systems that check hard access rules and models that check soft access rules. Now comes the most important part. You need to set up your own continuous training flywheel, so that you can improve your AI systems based on their interaction with your employees and your users. This is how you turn the edges of your business into AI systems your vendors and competitors cannot replicate. It’s also how you reduce deployment cost as well, as you can shrink models according to model input distribution. Those bills are getting substantial, we need to collectively become efficient if we want AI development to continue, so that matters. All of these efforts might seem daunting – they are. This is both a complete replatforming of your IT, and a complete change in the way you’re developing software, and operating your business. AI lifecycle management requires understanding human behavior and gradient descent, that’s a stretch. At Mistral, we facilitate that work by providing all primitives that you need in a single control plane, Studio, and a training platform, Forge. With our applied AI engineers and scientists working hand-in-hand with our customers, we ensure that we transfer knowledge, and that we can disappear once the systems are up and running. We deploy on our customers' infrastructure, or through our zero-data-retention hosted services, so that your edges remain your edges, and the switch button can be fully in your hand. Frontier AI can accelerate the growth of your business, but if it’s not in your hands, it’s not going to be your growth.

OpenAI just launched an Agent Builder. Say goodbye to thousands of startups AI is progressing so fast, most founders don't know how to build defensibility. Here’s what the smartest founders do differently: 1. They own the data APIs are temporary. What compounds is your proprietary dataset. → throxy (yc x25) scrapes its own data instead of relying on LinkedIn or Apollo. Every interaction improves the product and makes it harder to replicate. 2. They build a UX moat When tech is commoditized, experience becomes the differentiator. → Granola is a meeting recorder, but what sets it apart is the interface. It feels delightful, fast, frictionless—like it was made for you, not for enterprise IT. In a world of clones, great UX builds loyalty. 3. They unlock power for non-technical users Defensibility comes from enabling outsiders to do what only experts could before. → Lovable turns brand design into something anyone can do. In minutes, non-designers generate entire visual identities. 4. They move up the stack Commoditized infra dies. Winners package it into workflows users already need. → Perplexity started as a research tool. Now it’s becoming an AI-native browser. Owning the user’s daily search habits is how you defend long-term. 5. They go deep, not wide Horizontal tools get replaced fast. But narrow use cases can dominate markets. → ElevenLabs focused on voice. It didn’t try to do everything—just build the best voice AI in the world. Now it powers thousands of creators and companies. What am I missing? Full breakdown in my last article: https://lnkd.in/dSbpWnBz

Building AI agents = 5% AI + 95% software engineering. Not exact ratio, but you get the point. We don’t just “build an agent”; we architect a system and let the AI sit inside it. Enterprise-ready agent platforms are classic software + reliability engineering work: ✅ Identity and access management ✅ Document filtering and governance (ACLs, redaction, PII masking) ✅ Schema mapping and data contracts ✅ Human-in-the-loop escalation ✅ Infra that scales across vector and SQL ✅ Observability, evals, guardrails, cost controls, and audit logs Think of agents like APIs that can reason, not magic. They still need: - Fine-grained access control - Storage that separates structured and unstructured knowledge - Tracing, fallback routing, and lineage - Flows that connect document pipelines with model orchestration (MCP, tools, integrations) Before you tune prompts, build the foundations. If you’re exploring agent workflows, check out our open-source platform, a lightweight framework we use to run multi-agent systems: GitHub: https://bit.ly/4kzE1Mt Explore our public investment: 🔗https://bit.ly/41JeDNO __________ For more on AI and learning materials, plz check my previous posts. I share my journey here. Join me and let's grow together. Alex Wang #AIagents #AgenticAI #EnterpriseAI #Technology

The New York Times profiled a start-up with 28 employees serving nearly 50 million users. That company is us. The traditional startup playbook: raise massive funding, hire hundreds of employees, and worry about profitability "later." But there's another way. Everyone at Gamma could fit in a small restaurant. We're not just surviving—we've been profitable for 15+ consecutive months, with revenue growing month over month, and lifetime negative net burn (we have more money in the bank than we've raised). This isn't an accident. We've deliberately designed our organization to maximize impact per person. Instead of creating specialist silos, we hire versatile generalists who can solve problems across domains. Rather than building management hierarchies, we find player-coaches who both lead and execute. Our team leverages AI tools throughout our workflow - Claude for data analysis, Cursor for coding efficiency, NotebookLM for customer research synthesis. These aren't just productivity hacks; they're force multipliers. Examples: — When our growth PM needed better analytics, he didn't file a ticket with a data team—he built a self-serve system that anyone can use without SQL knowledge. — When our marketing lead needed to understand our customers better, she fed thousands of interactions into an LLM and created actionable personas that now guide our entire strategy. — When our design team needs to test a hypothesis, we create a rapid prototype and show it to our power users. What we're seeing isn't just about "doing more with less." It's about fundamentally changing what's possible per person. The most valuable employees aren't specialists who excel in narrow domains - they're resourceful problem-solvers who continuously expand their capabilities. This approach creates remarkable resilience. Since everyone understands multiple functions, we don't have single points of failure when someone leaves or moves to another project. If you're building today, the question isn't how quickly you can scale headcount … it's how much impact you can create with the smallest possible team. The future belongs to tiny teams of extraordinary people.

"Vibe Coding !== Low Quality Work: a guide to responsible AI-assisted dev" ✍️ My latest free article: https://lnkd.in/gjMdjMWV The allure of "vibe coding" – using AI to "move faster and break even more things" – is strong. AI-assisted development is undeniably transformative, lowering barriers and boosting productivity. But speed without quality is a dangerous trap. Relying uncritically on AI-generated code can lead to brittle "house of cards" systems, amplify tech debt exponentially, and introduce subtle security flaws. Volume ≠ Quality. A helpful mental model I discuss (excellently illustrated by Forrest Brazeal) is treating AI like a "very eager junior developer." It needs guidance, review, and refinement from experienced hands. You wouldn't let a junior ship unreviewed code, right? So how do we harness AI's power responsibly? I've outlined a field guide with practical rules: ✅ Always review: Treat AI output like a PR from a new hire. ✅ Refactor & test: Inject engineering wisdom – clean up, handle edge cases, test thoroughly. ✅ Maintain standards: Ensure AI code meets your team's style, architecture, and quality bar. ✅ Human-led design: Use AI for implementation grunt work, not fundamental architecture decisions. The goal isn't to reject vibe coding, but to integrate it with discipline. Let's use AI to augment our craft, pairing machine speed with human judgment. #softwareengineering #programming #ai

𝗧𝗵𝗲 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁𝘀 𝗦𝘁𝗮𝗶𝗿𝗰𝗮𝘀𝗲 represents the 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱 𝗲𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 from passive AI models to fully autonomous systems. Each level builds upon the previous, creating a comprehensive framework for understanding how AI capabilities progress from basic to advanced: BASIC FOUNDATIONS: • 𝗟𝗮𝗿𝗴𝗲 𝗟𝗮𝗻𝗴𝘂𝗮𝗴𝗲 𝗠𝗼𝗱𝗲𝗹𝘀: The foundation of modern AI systems, providing text generation capabilities • 𝗘𝗺𝗯𝗲𝗱𝗱𝗶𝗻𝗴𝘀 & 𝗩𝗲𝗰𝘁𝗼𝗿 𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀: Critical for semantic understanding and knowledge organization • 𝗣𝗿𝗼𝗺𝗽𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴: Optimization techniques to enhance model responses • 𝗔𝗣𝗜𝘀 & 𝗘𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝗗𝗮𝘁𝗮 𝗔𝗰𝗰𝗲𝘀𝘀: Connecting AI to external knowledge sources and services INTERMEDIATE CAPABILITIES: • 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁: Handling complex conversations and maintaining user interaction history • 𝗠𝗲𝗺𝗼𝗿𝘆 & 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗠𝗲𝗰𝗵𝗮𝗻𝗶𝘀𝗺𝘀: Short and long-term memory systems enabling persistent knowledge • 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗖𝗮𝗹𝗹𝗶𝗻𝗴 & 𝗧𝗼𝗼𝗹 𝗨𝘀𝗲: Enabling AI to interface with external tools and perform actions • 𝗠𝘂𝗹𝘁𝗶-𝗦𝘁𝗲𝗽 𝗥𝗲𝗮𝘀𝗼𝗻𝗶𝗻𝗴: Breaking down complex tasks into manageable components • 𝗔𝗴𝗲𝗻𝘁-𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸𝘀: Specialized tools for orchestrating multiple AI components ADVANCED AUTONOMY: • 𝗠𝘂𝗹𝘁𝗶-𝗔𝗴𝗲𝗻𝘁 𝗖𝗼𝗹𝗹𝗮𝗯𝗼𝗿𝗮𝘁𝗶𝗼𝗻: AI systems working together with specialized roles to solve complex problems • 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀: Structured processes allowing autonomous decision-making and action • 𝗔𝘂𝘁𝗼𝗻𝗼𝗺𝗼𝘂𝘀 𝗣𝗹𝗮𝗻𝗻𝗶𝗻𝗴 & 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻-𝗠𝗮𝗸𝗶𝗻𝗴: Independent goal-setting and strategy formulation • 𝗥𝗲𝗶𝗻𝗳𝗼𝗿𝗰𝗲𝗺𝗲𝗻𝘁 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 & 𝗙𝗶𝗻𝗲-𝗧𝘂𝗻𝗶𝗻𝗴: Optimization of behavior through feedback mechanisms • 𝗦𝗲𝗹𝗳-𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 𝗔𝗜: Systems that improve based on experience and adapt to new situations • 𝗙𝘂𝗹𝗹𝘆 𝗔𝘂𝘁𝗼𝗻𝗼𝗺𝗼𝘂𝘀 𝗔𝗜: End-to-end execution of real-world tasks with minimal human intervention The Strategic Implications: • 𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗗𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁𝗶𝗮𝘁𝗶𝗼𝗻: Organizations operating at higher levels gain exponential productivity advantages • 𝗦𝗸𝗶𝗹𝗹 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁: Engineers need to master each level before effectively implementing more advanced capabilities • 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗣𝗼𝘁𝗲𝗻𝘁𝗶𝗮𝗹: Higher levels enable entirely new use cases from autonomous research to complex workflow automation • 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗥𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀: Advanced autonomy typically demands greater computational resources and engineering expertise The gap between organizations implementing advanced agent architectures versus those using basic LLM capabilities will define market leadership in the coming years. This progression isn't merely technical—it represents a fundamental shift in how AI delivers business value. Where does your approach to AI sit on this staircase?

AI Product Management AI Product Management is evolving rapidly. The growth of generative AI and AI-based developer tools has created numerous opportunities to build AI applications. This is making it possible to build new kinds of things, which in turn is driving shifts in best practices in product management — the discipline of defining what to build to serve users — because what is possible to build has shifted. In this post, I’ll share some best practices I have noticed. Use concrete examples to specify AI products. Starting with a concrete idea helps teams gain speed. If a product manager (PM) proposes to build “a chatbot to answer banking inquiries that relate to user accounts,” this is a vague specification that leaves much to the imagination. For instance, should the chatbot answer questions only about account balances or also about interest rates, processes for initiating a wire transfer, and so on? But if the PM writes out a number (say, between 10 and 50) of concrete examples of conversations they’d like a chatbot to execute, the scope of their proposal becomes much clearer. Just as a machine learning algorithm needs training examples to learn from, an AI product development team needs concrete examples of what we want an AI system to do. In other words, the data is your PRD (product requirements document)! In a similar vein, if someone requests “a vision system to detect pedestrians outside our store,” it’s hard for a developer to understand the boundary conditions. Is the system expected to work at night? What is the range of permissible camera angles? Is it expected to detect pedestrians who appear in the image even though they’re 100m away? But if the PM collects a handful of pictures and annotates them with the desired output, the meaning of “detect pedestrians” becomes concrete. An engineer can assess if the specification is technically feasible and if so, build toward it. Initially, the data might be obtained via a one-off, scrappy process, such as the PM walking around taking pictures and annotating them. Eventually, the data mix will shift to real-word data collected by a system running in production. Using examples (such as inputs and desired outputs) to specify a product has been helpful for many years, but the explosion of possible AI applications is creating a need for more product managers to learn this practice. Assess technical feasibility of LLM-based applications by prompting. When a PM scopes out a potential AI application, whether the application can actually be built — that is, its technical feasibility — is a key criterion in deciding what to do next. For many ideas for LLM-based applications, it’s increasingly possible for a PM, who might not be a software engineer, to try prompting — or write just small amounts of code — to get an initial sense of feasibility. [Reached length limit. Full text: https://lnkd.in/gYY-hvHh ]

AI holds great potential for the semiconductor industry and will kick-start the next round of innovation for faster, cheaper and more energy-efficient computation – that was my message today at SPIE Advanced Lithography + Patterning. I discussed the potential and the challenges that AI holds for our industry.   The potential is clearly huge. AI is rapidly integrated into applications, and high-performance compute is expected to underpin growth towards $1 trillion of semiconductor sales by 2030. The challenges are around the computing needs of AI models and related energy consumption. The compute workload of training a leading AI model has increased 16x every 2 years in recent years – much faster than the increase in computing power delivered by Moore’s law, which is about 2x every 2 years. The energy needed to train a leading model has not grown so steeply but still rose 10x every 2 years. This computing need has been met by building supercomputers and massive data centers. If you extrapolate these trends, training a leading AI model would need the entire world-wide electricity supply in about 10 years. That’s clearly not realistic, so the trend has to break, by training algorithms becoming more efficient and by chips becoming more efficient. In other words, the needs of AI will stimulate immense innovation in chip design and manufacturing – and the potential value of AI to our society will put urgency and funding behind that drive. As a consequence, chip makers are pulling all levers to accelerate semiconductor scaling. This includes lithographic “2D” scaling: shrinking the dimensions of transistors to pack more into a square millimeter. It will also include “3D” integration, with innovations like backside power delivery, transistor designs like gate-all-around, as well as stacking chips in the package, where holistic lithography will play a critical role to deliver performance requirements. ASML will support these trends through a comprehensive, holistic lithography portfolio. Our 0.33 NA/0.55 NA EUV lithography systems allow chip makers to shrink dimensions at the lowest possible cost on their critical layers, while tightly matched and highly productive DUV systems will continue to reduce cost. More than ever, metrology and inspections tools – whose data is fed into lithography control solutions that keep the patterning process operating within tight specs to deliver the highest possible production yields – will be essential to deliver 2D scaling and 3D integration processes. 3D integration requires wafer-to-wafer bonding, and we have demonstrated the capability to map the stresses and distortions that bonding creates and to compensate for them, reducing overlay errors for post-bonding patterning by 10x or more.   It was a pleasure catching up with the industry’s lithography and patterning experts in San Jose. I’m excited to see our collective innovation power having a go at these challenges. Together, we will push technology forward.

Anthropic 𝗷𝘂𝘀𝘁 𝗿𝗲𝗹𝗲𝗮𝘀𝗲𝗱 𝗮 𝗱𝗲𝗻𝘀𝗲 𝗮𝗻𝗱 𝗵𝗶𝗴𝗵𝗹𝘆 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗿𝗲𝗽𝗼𝗿𝘁 𝗼𝗻 𝗵𝗼𝘄 𝘁𝗼 𝗯𝘂𝗶𝗹𝗱 𝗲𝗳𝗳𝗲𝗰𝘁𝗶𝘃𝗲 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 — 𝗽𝗮𝗰𝗸𝗲𝗱 𝘄𝗶𝘁𝗵 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝗳𝗿𝗼𝗺 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁𝘀: ⬇️ Not just marketing, BUT a real, practical blueprint for developers and teams building AI agents that actually work. It explains how Claude Code (tool for agentic coding) can function as a software developer: writing, reviewing, testing, and even managing Git workflows autonomously. BUT in my view: The principles and patterns described in this document are not Claude-specific. You can apply them to any coding agent — from OpenAI’s Codex to Goose, Aider, or even tools like Cursor and GitHub Copilot Workspace. 𝗛𝗲𝗿𝗲 𝗮𝗿𝗲 7 𝗸𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝗳𝗼𝗿 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗯𝗲𝘁𝘁𝗲𝗿 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 — 𝘁𝗵𝗮𝘁 𝘄𝗼𝗿𝗸 𝗶𝗻 𝘁𝗵𝗲 𝗿𝗲𝗮𝗹 𝘄𝗼𝗿𝗹𝗱: ⬇️ 1. 𝗔𝗴𝗲𝗻𝘁 𝗱𝗲𝘀𝗶𝗴𝗻 ≠ 𝗷𝘂𝘀𝘁 𝗽𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴 ➜ It’s not about clever prompts. It’s about building structured workflows — where the agent can reason, act, reflect, retry, and escalate. Think of agents like software components: stateless functions won’t cut it. 2. 𝗠𝗲𝗺𝗼𝗿𝘆 𝗶𝘀 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 ➜ The way you manage and pass context determines how useful your agent becomes. Using summaries, structured files, project overviews, and scoped retrieval beats dumping full files into the prompt window. 3. 𝗣𝗹𝗮𝗻𝗻𝗶𝗻𝗴 𝗶𝘀𝗻’𝘁 𝗼𝗽𝘁𝗶𝗼𝗻𝗮𝗹 ➜ You can’t expect an agent to solve multi-step problems without an explicit process. Patterns like plan > execute > review, tool use when stuck, or structured reflection are necessary. And they apply to all models, not just Claude. 4. 𝗥𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗮𝗴𝗲𝗻𝘁𝘀 𝗻𝗲𝗲𝗱 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝘁𝗼𝗼𝗹𝘀 ➜ Shell access. Git. APIs. Tool plugins. The agents that actually get things done use tools — not just language. Design your agents to execute, not just explain. 5. 𝗥𝗲𝗔𝗰𝘁 𝗮𝗻𝗱 𝗖𝗼𝗧 𝗮𝗿𝗲 𝘀𝘆𝘀𝘁𝗲𝗺 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀, 𝗻𝗼𝘁 𝗺𝗮𝗴𝗶𝗰 𝘁𝗿𝗶𝗰𝗸𝘀 ➜ Don’t just ask the model to “think step by step.” Build systems that enforce that structure: reasoning before action, planning before code, feedback before commits. 6. 𝗗𝗼𝗻’𝘁 𝗰𝗼𝗻𝗳𝘂𝘀𝗲 𝗮𝘂𝘁𝗼𝗻𝗼𝗺𝘆 𝘄𝗶𝘁𝗵 𝗰𝗵𝗮𝗼𝘀 ➜ Autonomous agents can cause damage — fast. Define scopes, boundaries, fallback behaviors. Controlled autonomy > random retries. 7. 𝗧𝗵𝗲 𝗿𝗲𝗮𝗹 𝘃𝗮𝗹𝘂𝗲 𝗶𝘀 𝗶𝗻 𝗼𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 ➜ A good agent isn’t just a wrapper around an LLM. It’s an orchestrator: of logic, memory, tools, and feedback. And if you’re scaling to multi-agent setups — orchestration is everything. Check the comments for the original material! Enjoy! Save 💾 ➞ React 👍 ➞ Share ♻️ & follow for everything related to AI Agents!

If you don't understand this, you will not understand why LLM-based agents are irreparably failing for a general-purpose problem solving. An agent (by the way it was the topic of my PhD 20 years ago) to be useful, must be rational. Being rational means to always prefer an outcome that results in the maximal expected utility to its master/user. Let’s say an agent has two actions they can execute in an environment: a_1 and a_2. If the agent can predict that a_1 gives its user an expected utility of 10, and a_2 gives an expected utility of -100, then a rational agent must choose a_1 even if choosing a_2 seems like a better option when explained in words. The numbers 10 and -100 can be obtained by summing the products of all possible outcomes for each action and their likelihoods. Now here is the problem with LLM-based agents. The LLM is not optimizing expected utility in the environment. It is optimizing the next token, conditioned on a prompt, a context window, and a training distribution full of examples of what helpful answers are supposed to look like. Those are not the same objective. So when we wrap an LLM in a loop and call it an “agent,” we have not created a rational decision-maker. We have created a text generator that can imitate the surface form of deliberation. It may say things like: “I should compare the expected outcomes.” “The best action is probably a_1.” “I will now execute the optimal plan.” But the internal mechanism is not selecting actions by maximizing the user’s expected utility. It is generating a continuation that is statistically appropriate given the prompt and prior context. This distinction matters enormously. For narrow tasks, the imitation can be good enough. If the environment is constrained, the actions are simple, and the success criteria are close to patterns seen in training, the system can appear agentic. But for general-purpose problem solving, the gap becomes fatal. A rational agent needs stable preferences, calibrated beliefs, causal models of the world, the ability to evaluate consequences, and the discipline to choose the action with maximal expected utility even when that action is boring, non-linguistic, or unlike the examples in its training data. An LLM-based agent has none of that by default. It has fluency. It has pattern completion. It has a remarkable ability to compress and recombine human text. But fluency is not rationality, and a plausible plan is not an expected-utility calculation. This is why these systems so often fail in strange, brittle, and irreparable ways when given open-ended responsibility. They are not failing because the prompts are insufficiently clever. They are failing because we are asking a simulator of rational agency to be a rational agent.