<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Oladipo Fasoro on Medium]]></title>
        <description><![CDATA[Stories by Oladipo Fasoro on Medium]]></description>
        <link>https://medium.com/@chilled_techie?source=rss-6d5b931047f2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*AKHCVe1eIk2sQ5W5hRT6HA.jpeg</url>
            <title>Stories by Oladipo Fasoro on Medium</title>
            <link>https://medium.com/@chilled_techie?source=rss-6d5b931047f2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 10:25:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@chilled_techie/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[You don’t need permission to build.]]></title>
            <link>https://medium.com/@chilled_techie/you-dont-need-permission-to-build-eea894f01304?source=rss-6d5b931047f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/eea894f01304</guid>
            <category><![CDATA[women-in-tech]]></category>
            <category><![CDATA[disruption]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Oladipo Fasoro]]></dc:creator>
            <pubDate>Fri, 05 Jun 2026 18:18:18 GMT</pubDate>
            <atom:updated>2026-06-06T03:22:26.733Z</atom:updated>
            <content:encoded><![CDATA[<p>When I was asked as a 5 year old what I wanna be when I grew up, all I dreamt of was to maximize shareholder value by circling back on boiling the ocean, putting a pin on the bandwidth, deep diving on the low hanging fruit, and aligning synergies with the action items. Lol</p><p>Seriously, one thing I would love to tell the younger generation of Builders (and even us older ones) is to remember that they can just build things. Doesn’t have to be the shiniest thing, latest tech, SAAS, mobile-app, cloud AI-based, or even be commercial.</p><p>Feel free to build what you are passionate about. Feel free to be opinionated about stuff you don’t fundamentally agree with, and work on an alternative.</p><p>You can just do things, you don’t need a mandate, a roadmap, startup credits or whatever. That’s how people used to do it, then some of those people became industry leaders, got so “Big” and then tell/manipulate everyone else on how to do stuff.</p><p>You don’t like email portability issues, vendor locking, privacy issues/data-mining, you can literally propose a new protocol and build an alternative. And maybe in 10 years time, everyone stops using Email as is and use whatever you propose.</p><p>You don’t like how kids, the elderly and vulnerable parts of society are not protected on the Internet by current Internet standards/implementations and you feel so strongly about it, then do something, maybe in 5 years your proposal would be so successful that Apps would have to have a “KidSafe” certification for widespread adoption, just like we had the Secure Site Seal, or the Energy Star label.</p><p><strong>And if the vision is bigger than you, </strong>motivate others to join you on it, but don’t give up, don’t stop dreaming because the Industry seems to be going in one direction.</p><p>Use your free-will to build, don’t ask for mental permission, and of course build within legality/morality constraints</p><p>Don’t be like Mark Zuckerberg and build FaceMash though, that was creepy.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eea894f01304" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Effective Agents in non-coding domains.]]></title>
            <link>https://medium.com/@chilled_techie/building-effective-agents-in-non-coding-domains-4fa1a1702e13?source=rss-6d5b931047f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/4fa1a1702e13</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[genai]]></category>
            <dc:creator><![CDATA[Oladipo Fasoro]]></dc:creator>
            <pubDate>Tue, 09 Dec 2025 23:39:05 GMT</pubDate>
            <atom:updated>2025-12-10T00:01:16.564Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LwUZHi9kivCTTcTLBUcadQ.png" /><figcaption>Borrowing concepts from Agentic coding generation <a href="https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk#:~:text=Creating%20new%20types%20of%20agents">into other domains e.g. Product.</a></figcaption></figure><p>Last month, I wrote about <a href="https://medium.com/@chilled_techie/why-success-with-ai-coding-agents-will-not-automatically-translate-to-enterprise-ai-agents-2206ecbb8034">how success with coding agents will not immediately translate in enterprise AI</a>, today I am expanding on the reasoning. Coding agents routinely outperform agents in other domains. They can write high-quality code, fix bugs autonomously, and iterate on complex multi-file tasks toward working solutions with minimal human intervention. Meanwhile, agents tasked with product management, legal analysis, or financial modeling, etc struggle to maintain consistency across even simple tasks.</p><p>The conventional explanation is that code is somehow easier for AI, or that models have seen more training data on programming. While that is true, but this misses another core reason: <a href="https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk#:~:text=Building%20your%20agent%20loop">coding agents work</a> because they have decades of verification infrastructure to lean on. Compilers, type checkers, linters, and test suites provide crisp, actionable feedback that agents can iterate against. It’s not the agent that’s better. It’s the environment.</p><h4>The Code Verification Hierarchy</h4><p>Code has a natural hierarchy of verifiability, and agent effectiveness tracks this hierarchy almost perfectly:</p><ul><li><strong>Syntax errors</strong>: The agent knows immediately if code won’t parse.</li><li><strong>Type errors</strong>: Type checker points to exact structural mismatch.</li><li><strong>Linter warnings</strong>: Automated checks flag style issues, potential bugs, and code smells before execution.</li><li><strong>Test failures</strong>: provide automated verification of logic and behavior.</li><li><strong>Runtime behavior</strong>: Requires understanding user intent, not just correctness.</li></ul><p>When verification is crisp and mechanical, AI agents iterate rapidly toward syntactically and semantically correct solutions. An agent might start with start with a logically wrong or inconsistent approach, but as it tries to satisfy structural verification, it corrects itself. When feedback becomes ambiguous or requires human judgment, agents might become ineffective.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*w2Bfu1iCqRYXYC_R" /><figcaption><a href="https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk#:~:text=Building%20your%20agent%20loop">Effective Coding Agent Loop</a></figcaption></figure><blockquote>This explains<strong> why coding agents generally succeed while other domain agents struggle, </strong>and why coding agents are reported to work better in statically typed languages<strong>. The language and tooling ecosystem provides a tight feedback loop that agents can exploit to be more effective and reduce errors/hallucinations.</strong></blockquote><blockquote>Think if your Product Agent can receive feedback <strong>“B2B Model Incomplete: The B2C credit usage model is defined, but the corresponding B2B pooled credits model for multi-user accounts is missing. Define B2B model.”</strong> versus vague human feedback like <strong>‘this spec seems incomplete, check for inconsistencies’</strong></blockquote><h4>What This Could Look Like in Product Management</h4><p>Specifications are frequently undermined by structural and semantic errors that would be trivial for this proposed agentic system to catch, yet could routinely be missed by human editors/reviewers. Our approach allows Humans to mostly focus on the strategic angle.</p><p><strong>Examples:</strong></p><pre>ERROR: Inconsistent feature definition<br>  Feature: payment-method-selection<br>  payment-method-selection only defines the web experience, mobile experience<br>  required for full coverage<br><br>WARNING: Incomplete metric coverage<br>  Feature: shopping-cart<br>  Feature declares metrics but there are no stories that implements/tracks<br>  tracks them. Missing metrics: [&quot;Cart Abandonment Rate&quot;]<br><br>ERROR: Circular dependency detected<br>  checkout-flow → payment-gateway → user-authentication → checkout-flow<br>  <br>ERROR: Constraint violation<br>  Feature: real-time-collaboration<br>  Specifies: max_latency &lt; 100ms<br>  Depends on: document-sync-service (min_latency: 200ms)<br>  <br>WARNING: Missing test reference<br>  Feature: user-authentication<br>  Acceptance Criteria AC-001 has no linked test<br><br>WARNING: Deprecated reference detected<br>  Feature: payment-gateway-v2<br>  &#39;checkout-flow&#39; references deprecated &#39;payment-gateway-v2&#39;.<br>  Did you mean &#39;payment-gateway-v3&#39;?</pre><p>This is the same quality of feedback that makes coding agents effective. Clear, specific, mechanically verifiable. The agent can iterate against these errors just like it iterates against compiler errors and explore multiple solutions.</p><h4>The Pattern could be applied universally</h4><p>Legal contracts have the same problem: contradictory clauses, undefined terms used in obligations, unbalanced party responsibilities, references to non-existent sections. All mechanically detectable.</p><p>Financial models have contradictory assumptions, circular references between calculations, unsourced data claims, and constraint violations. All possibly verifiable.</p><p>Every domain with structured artifacts has verification opportunities. The difference is that software engineering invested decades building this infrastructure in the language itself. Other domains haven’t, or have it in specialized proprietary tooling.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_SoouqZYnwzuVPQpqBXpvw.png" /><figcaption>A demo for adding a discount code support checkout requirement to an Ecommerce product using <a href="https://github.com/midearth-labs/verifier/blob/main/docs/FEAT-REQ-CHECKOUT-001.md#requirements">prose</a> and <a href="https://github.com/midearth-labs/verifier/blob/d3099859bb1fa2dd755cd08ecb09cf7f9bad5aba/specs/checkout/FEAT-REQ-CHECKOUT-001.json#L257">structured data</a> , seen above is how the Linter discovered an unknown dependency, but temporarily ignored it as it was a placeholder to be defined later. The markdown converter generates the interactive output docs.</figcaption></figure><h4>How could this work? Representation Duality</h4><p>Our proposal is to maintain dual representations: natural language <strong>prose for humans</strong> alongside <strong>JSON schemas</strong> for machines and agents. A product manager writes “Authentication depends on user management and Google Login integration,” while an AI agent extracts {&quot;downstream_dependencies&quot;: [&quot;FEAT-12&quot;, &quot;FEAT-25&quot;]}. Humans think in narrative; agents operate on structure.</p><p>The verification power comes from giving agents query tools like <a href="https://jqlang.org/">jq</a> or <a href="https://jsonata.org/">JSONata</a>, and rules to interrogate the structured layer. Agents can detect circular dependencies across hundreds of specs, identify orphaned features, or flag constraint violations where a feature requiring sub-500ms latency depends on components with 200ms SLAs each. These checks can run automatically on every change, just like a TypeScript compiler. The schema also enables rich generated UX: dependency mentions become clickable links, hover tooltips show feature status, inline warnings appear when referencing deprecated features.</p><p>The bidirectional sync creates the tight feedback loop that makes coding agents effective. When users edit prose, agents extract and update metadata automatically, flagging inconsistencies. When schemas change — a dependency gets deprecated, an upstream SLA shifts — agents scan prose to suggest updates or highlight newly-invalid assumptions. The human provides intent through prose; the agent ensures consistency through structure; verifiers catch violations before they cascade into implementation.</p><h4>The Path Forward</h4><p>The building blocks for verification infrastructure already exist. Verifiers can be implemented as hooks (simple scripts, standalone validation tools), or <a href="https://modelcontextprotocol.io/docs/getting-started/intro">Model Context Protocol</a> (MCP) servers that agents call before committing changes. The proposed architecture is straightforward: humans work in purpose-built interfaces optimized for their workflow, agents work with structured data optimized for reliability, and both operate on the same source of truth stored in a machine-readable format like JSON.</p><p>For product teams, this might mean a Notion-like editor for writing specs that translates to validated JSON underneath. For legal teams, a contract drafting interface that prevents contradictory clauses by construction. For architecture teams, a service catalog that won’t let you create circular dependencies.</p><p>The key insight is separation of concerns. Humans edit prose, agents are in charge of JSON, and can update prose to match. Each operates in their native modality, with verification infrastructure in between to drive superior agentic execution and ensure consistency.</p><p>This is our idea on how we make agents useful beyond coding: not only by building better models, but by building better environments.</p><h4>Call to action</h4><p>If you’re working on verification infrastructure for non-code domains, or if you’re struggling with agent effectiveness in product, legal, finance etc, we’d like to hear from you and we can build together to test these ideas out.</p><p>The future of useful AI agents isn’t about waiting for better models. It’s about building support infrastructure that lets current models work effectively. Code has shown us the way. Now it’s time to apply the same principles everywhere else.</p><h4>About the authors</h4><p>These concepts are authored by <strong>Oladipo Fasoro</strong>, Co-Founder @ MidEarth Labs/Agentic AI researcher, and <strong>Kehinde Fawumi</strong>, Product Leader @ Amazon/Forbes Tech Council Member. You can follow Oladipo on LinkedIn @ <a href="https://www.linkedin.com/in/dfasoro/"><strong>dfasoro</strong></a>, and Kehinde on LinkedIn @ <a href="https://www.linkedin.com/in/kehindefawumi/"><strong>kehindefawumi</strong></a>. We welcome connection and conversation on Agentic AI in product and other domains.</p><p><strong>References</strong>:</p><ul><li>Demo GitHub Repo: <a href="https://github.com/midearth-labs/verifier">https://github.com/midearth-labs/verifier</a></li><li>Anthropic: “Verify your work”: <a href="https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk#:~:text=Verify%20your%20work">https://www.anthropic.com/engineering/building-agents-with-the-claude-agent-sdk</a></li><li>Anthropic: “Structured outputs”: <a href="https://platform.claude.com/docs/en/build-with-claude/structured-outputs">https://platform.claude.com/docs/en/build-with-claude/structured-outputs</a></li><li>Anthropic: “Effective harnesses for long-running agents”: -<a href="https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents">https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4fa1a1702e13" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From ReAct Loops to Compiled Workflows: An alternative way to Agentic AI]]></title>
            <link>https://medium.com/@chilled_techie/from-react-loops-to-compiled-workflows-an-alternative-way-to-agentic-ai-d439390214a6?source=rss-6d5b931047f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/d439390214a6</guid>
            <category><![CDATA[langchain]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Oladipo Fasoro]]></dc:creator>
            <pubDate>Fri, 21 Nov 2025 21:26:33 GMT</pubDate>
            <atom:updated>2025-11-21T21:56:41.130Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aVBTLpqzWZnawvOsReYe-A.png" /><figcaption>WAP V2— LLM Plan-And-Execute with Client-Side Workflow Orchestration.</figcaption></figure><h3>The Challenge with ReAct Loop-Based Execution</h3><p>When I designed the first draft of <a href="https://medium.com/@chilled_techie/wap-bringing-natural-language-to-the-web-for-all-d45520d3388e">Web Agent Protocol (WAP)</a> / (demos linked <a href="https://www.linkedin.com/posts/dfasoro_agentic-ai-activity-7394311865176293376-jPK0">here</a>), I approached it in the typical ReAct loop with the LLM as the orchestrator and tools execute in the environment. The LLM calls a tool, observes the result, decides the next step, repeat.</p><p>But then it occurred to me, WAP isn’t trying to be an exploratory assistant. It’s designed with a specific approach in mind:</p><ol><li>User makes a natural language request</li><li>LLM generates a plan, and is presented for user approval</li><li>User approves or refines it</li><li>Execution begins with well-defined service tools/functionalities</li></ol><p>More importantly, WAP doesn’t create new server-side functionality. It orchestrates existing capabilities, so, once the plan is approved, why keep calling the LLM<strong> in a ReAct loop</strong>? Every additional LLM call adds latency, costs/burns tokens, and introduces points of failure. Context windows bloat with repetitive information. The model might drift from the original intent across multiple calls due to missed instructions / hallucinations. This is well observed and documented in the industry.</p><h4>Addressing the Challenge</h4><p>My first thought was to have the LLM generate JavaScript code representing the approved plan. Execute it client-side, never go back to the LLM. Simple.</p><p>But of course as a security aware engineer, I knew this was problematic. Anthropic has also been thinking similarly (<a href="https://www.anthropic.com/engineering/code-execution-with-mcp">code execution tool</a>) and they also called out the security concerns/tradeoffs and their approach to solving them.</p><ul><li>Can we trust generated code/hijacking?</li><li>Do we need sandboxing (iframes, web workers, CSP)?</li><li>How do we limit what’s possible or accessible?</li></ul><p>I then thought of using or creating a state machine language. I considered <a href="https://states-language.net/spec.html">Amazon States Language</a> (ASL) which I was familiar with. It’s a DSL domain-specific language with fixed boundaries, not a GPL general-purpose programming language. But ASL’s operation/transformation capabilities (<a href="https://en.wikipedia.org/wiki/JSONPath">JSONPath</a>) seemed limited or that was what I thought.</p><p>I considered building a custom DSL similar to ASL with extended transformation states to drop-in to unsafe code. Then I’d need to teach the LLM a new syntax, provide tons of examples, hope it generates valid output. Pass.</p><p>Then I saw Dorianna’s<a href="https://www.linkedin.com/posts/dorianna-leontiadou_accelerate-workflow-development-with-enhanced-activity-7397069557238030336-rT_5"> LinkedIn post</a> about some new step functions feature and while reading through the links, I discovered <a href="https://docs.aws.amazon.com/step-functions/latest/dg/transforming-data.html#writing-jsonata-expressions-in-json-strings">JSONata integration with Step Functions</a>, and it all clicked. Use a tested DSL schema for orchestration (like Amazon States Language), and use a tested and trusted data manipulation GPL (<a href="https://jsonata.org/">JSONata</a>)! Security problem solved.</p><h4>Why This Works</h4><p>LLMs are already trained on TypeScript, JavaScript, JSONata, and Amazon States Language from GitHub and Stack Overflow. Why fight that? Use what the model already knows, play to it’s strengths.</p><h4>WAP WorkFlow Architecture</h4><p><strong>Before (V1):</strong></p><ul><li>LLM prompts with tool definitions as OpenAPI schemas</li><li>LLM generates plan and User confirms</li><li><strong>LLM orchestrates back-and-forth, calling tools in a loop</strong></li></ul><p><strong>After (V2):</strong></p><ul><li>LLM prompts with tool definitions as TypeScript code blocks</li><li>Directive to output modified Amazon States Language with JSONata</li><li>LLM generates plan (once), and User confirms</li><li><strong>Client-side WAP Executor runs the workflow, zero LLM calls</strong></li></ul><p>The plan displays as both text and a visual diagram. Users can refine it with natural language to get an updated workflow. Once approved, WAP Executor executes entirely client-side. The plan generation worked on the first try.</p><h4>Understanding Plan-and-Execute Patterns</h4><p>The software engineering community has been exploring <a href="https://blog.langchain.com/planning-agents/">plan-and-execute agents</a> as an alternative to ReAct-style loops. The core idea: separate planning from execution.</p><p>In Traditional <strong>ReAct</strong> agents work like this, every step requires an LLM call. This is required for truly explorative problems where follow-on decisions and actions are not bounded, and are only discovered after the environment is observed. But not all problems are so, infact many problems are not so. <strong>Plan-and-execute</strong> agents take advantage of this insight by forcing the LLM to think step by step before action:</p><ol><li>Generate a full plan upfront</li><li>Execute each step sequentially and report</li><li>Only call the LLM again if replanning is needed</li></ol><p>This saves costs because you can use smaller models for execution steps. The large model only handles planning and generating final responses. Variations include: <a href="https://arxiv.org/abs/2305.18323">ReWOO</a>, <a href="https://arxiv.org/abs/2407.02524">LLMCompiler</a> etc. But here’s the thing: these approaches still need an LLM or interpreter during execution. ReWOO needs a “Solver” to interpret tool results.</p><h4>How WAP V2 Extends Plan-and-Execute</h4><p>WAP V2 takes plan-and-execute to its logical conclusion: <strong>generate executable logic within the calling environment.</strong></p><p>Traditional plan-and-execute: Planning LLM → Plan (text/JSON) → Execution LLM/Interpreter → Actions</p><p>WAP V2: Planning LLM → Executable Workflow (ASL + JSONata) → Direct Execution</p><p>The generated workflow isn’t a description of what to do. It IS what executes. There’s no interpretation layer. Tool calls are bound directly in Task states. Transformations are JSONata expressions evaluated by the executor. Conditionals are Choice states with JSONata predicates.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DlyVc7LQLO64SXNa93rNjQ.png" /><figcaption>WAP V2 orchestrating a functionality that a website’s APIs doesn’t have (CSV Generation)</figcaption></figure><h4><strong>What’s Missing: The Exploration Challenge</strong></h4><p>ReAct systems that explore and adapt at runtime can backtrack, try alternatives, listen to feedback, adjust until finding a solution. Static workflow generation can’t do that. LLMs are probabilistic. They make best-guess decisions. WAP’s user-confirmation model mitigates this since users can iteratively refine plans. But other use cases might need runtime exploration.</p><h4>Finite Exploration: A Middle Ground</h4><p>Consider the request: “Find my urgent todos.” This is ambiguous. It could mean:</p><ul><li>Todos with priority=&quot;urgent&quot; (field match)</li><li>Todos with “urgent” in the title (text search)</li><li>Todos with “urgent” in the description (text search)</li></ul><p>With finite exploration, the LLM doesn’t commit to one interpretation. It generates multiple strategies and lets execution determine which succeeds.</p><p>To achieve this, I’m proposing a new workflow state type: <strong>Serial State</strong></p><p>Here’s how it works with the “urgent todos” example:</p><pre>TryFindingUrgent (Serial State)<br>├── Strategy1: Filter by priority=&quot;urgent&quot;<br>├── Strategy2: Search title for &quot;urgent&quot;<br>└── Strategy3: Search description for &quot;urgent&quot;<br>    <br>BreakCondition: $data.totalCount &gt; 0<br>(Stop as soon as any strategy finds results)</pre><p>The LLM generates three candidate strategies at design-time. The executor tries each sequentially, accumulating results and tracking which strategy succeeded. As soon as one finds results (totalCount &gt; 0), execution breaks and proceeds to display the findings.</p><p>This is “compiled exploration”: the LLM explores possibilities at design-time, generates multiple execution branches, and the runtime system selects the successful path based on actual results. The system “figures out” what you mean through finite exploration rather than requiring precise language.</p><p>See the <a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/wap-states/wapv2-demo-examples.md#user-request-2-find-my-urgent-todos">full state machine example</a> and <a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/wap-states/tools-demo-request-2.json">tool definitions</a> in the WAP repository.</p><h4>Research Context and Critique</h4><p>The distinction between workflows (predefined orchestration) and agents (dynamic self-direction) is well established. Recent work on <a href="https://arxiv.org/html/2406.05804v1">LLM agents</a> identifies common patterns: policy-only workflows, search-based workflows, and feedback-learning workflows.</p><p><a href="https://www.anthropic.com/research/building-effective-agents">Anthropic’s research on building agents</a> notes that workflows offer predictability for well-defined tasks, while agents provide flexibility for model-driven decision-making at scale. <strong>Their recommendation: find the simplest solution possible, only increase complexity when needed.</strong></p><h4>Where WAP V2 approach Excels</h4><p><strong>Cost and latency</strong>: Popular Plan-and-execute agents reduce costs by using smaller models for execution. WAP V2 eliminates LLM calls entirely during execution.</p><p><strong>Auditability</strong>: The generated workflow is an artifact you can review, and analyze. It’s transparent in ways that ReAct loops aren’t.</p><p><strong>Determinism</strong>: Workflows excel when you need consistency, repeatability, and compliance. Enterprise environments often value predictability over flexibility.</p><p><strong>Security</strong>: Using ASL with JSONata provides clear boundaries about what’s possible. No arbitrary code execution concerns.</p><h4>Where It Falls Short</h4><p><strong>No runtime adaptation</strong>: If tool calls return unexpected results, WAP V2 can’t replan. It can only fail gracefully or retry with the same plan.</p><p><strong>Single-shot planning bias</strong>: One planning pass might not generate optimal solutions for complex problems. Research on <a href="https://arxiv.org/html/2404.07456v1">exploration vs exploitation in LLMs</a> shows that agents need both to handle complex tasks effectively. Serial States improve the chances.</p><p><strong>Limited problem scope</strong>: Best suited for well-defined tasks where the user/author can validate the plan upfront, my argument is that not many enterprise systems falls or (should) fall under open exploratory problems. Open-ended research, Coding agents, Log analysis etc, or highly uncertain environments still needs runtime adaptation.</p><h4>Next Steps</h4><p>I’m implementing WAP Executor next, including the Serial State exploration mechanism. This will test whether bounded exploration provides sufficient adaptability without sacrificing the cost, latency, and reliability benefits.</p><p>Follow/Star the <a href="https://github.com/midearth-labs/web-agent-protocol/tree/main">WAP project</a> on GitHub.</p><p>The future of enterprise Agentic AI might not be autonomous systems running wild. It is not purely static workflows. It might be intelligent planning combined with deterministic execution. The answer probably lies somewhere in the spectrum, and WAP V2 with Serial States is exploring that middle ground and in a subsequent article, I am gonna introduce the concept of <strong>AD-HA-WE</strong> (Agent-Designed, Human-Approved, Workflow-Executed) approach to reliable enterprise Agentic AI, Stay tuned</p><p><em>Enjoying this research? Follow me on LinkedIn, Consider </em><a href="https://github.com/sponsors/midearth-labs"><em>sponsoring MidEarth Labs</em></a>, and starring the <a href="https://github.com/midearth-labs/web-agent-protocol/tree/main">WAP Repo</a>, share this with your network as well<em>. </em>Do you think WAP’s approach might benefit your organization? Feel free to comment and connect?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d439390214a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[WAP: Bringing Natural Language to the Web for all]]></title>
            <link>https://medium.com/@chilled_techie/wap-bringing-natural-language-to-the-web-for-all-d45520d3388e?source=rss-6d5b931047f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/d45520d3388e</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[chatbots]]></category>
            <dc:creator><![CDATA[Oladipo Fasoro]]></dc:creator>
            <pubDate>Mon, 10 Nov 2025 00:05:12 GMT</pubDate>
            <atom:updated>2025-11-11T03:59:06.818Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A cooperative protocol that makes every website conversational — no new browser, software, or device needed</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8fnAjY0vSFyMkp594FuyhQ.png" /><figcaption>WAP Browser Experience</figcaption></figure><h4>The Evolution of Web Interaction</h4><p>The web has evolved through distinct interaction paradigms:</p><p><strong>1990s: Document Navigation</strong> — Click links, read pages<br><strong>2000s: Interactive Applications</strong> — Forms, AJAX, rich web apps<br><strong>2010s: Mobile-First &amp; Responsive</strong> — Touch interfaces, app-like experiences<br><strong>2020s: The Conversational Web</strong> — Natural language as a major contender.</p><p>We’re entering an era where users expect to interact with websites the way they interact with AI assistants — through natural conversation. Instead of hunting through menus, filling out forms, and clicking through multi-step workflows, users want to simply ask for what they need.</p><p><strong>“Find me a 30 lbs dumbbell with very good rating, my budget is max $100”</strong></p><p><strong>“Push all incomplete todos due this week to next Monday, except anything with ‘urgent’”</strong></p><p>This isn’t science fiction — it’s the logical next step in web evolution. Just as chatbots became ubiquitous on websites over the past decade, <strong>agentic interfaces</strong> are becoming the new standard for web interaction.</p><h4>What Makes This Possible Now?</h4><p>Three converging technologies:</p><ol><li><strong>Large Language Models</strong> — Understanding natural language intent with high accuracy</li><li><strong>Function Calling / Tool Use</strong> — LLMs that can invoke structured API/capabilities reliably</li><li><strong>Modern Web APIs</strong> — Most sites already have JSON APIs powering their SPAs</li></ol><p>The question isn’t <em>if</em> users/websites will adopt conversational interfaces — it’s <em>how</em> it can be done safely, reliably, and at scale.</p><h4>Introducing WAP (Web Agent Protocol)</h4><p>WAP is the code-name of a lightweight protocol that brings natural language interfaces to any website — <strong>no browser extensions, no new software, no complex integrations.</strong></p><p>Think of it like the chatbot widgets you already see on thousands of websites. Except instead of just answering questions, WAP-enabled sites let users accomplish actual tasks through conversation.</p><h4>How It Works (The Simple Version)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VcMBcGky9CgkkpaDTzYPEA.png" /><figcaption><em>WAP Orchestrator Flow — Simple and Familiar</em></figcaption></figure><p><strong>Three ingredients:</strong></p><ol><li><strong>A manifest file</strong> — Website publishes /.well-known/wap.json declaring what it can do</li><li><strong>The WAP Engine</strong> — A simple injectable JavaScript library (like Google Analytics or Stripe)</li><li><strong>The Websites Inference Endpoint</strong> — A simple wrapper around LLM calls for Agentic planning</li><li><strong>Agent mode</strong> — Activated via URL parameter or button click</li></ol><p>That’s it. No browser changes needed. No vendor approvals required. Just like how chatbots spread organically, WAP can too.</p><h4>It’s Just Like Chatbots… But Better</h4><p>If you’ve integrated or used a chatbot widget before, you already understand the WAP model. The key difference? Chatbots typically just answer questions. WAP agents can <strong>take action</strong> — search products, update settings, complete transactions, manage data.</p><h4>A Real Example: Todo Management</h4><p>Here’s what a simple Todo app looks like with WAP:</p><p><strong>1. Publish a manifest</strong> (/.well-known/wap.json):</p><pre>{<br>  &quot;name&quot;: &quot;TodoApp&quot;,<br>  &quot;version&quot;: &quot;1.0&quot;,<br>  &quot;tools&quot;: [<br>    {<br>      &quot;name&quot;: &quot;listTodos&quot;,<br>      &quot;tags&quot;: [&quot;readonly&quot;, &quot;paginated&quot;],<br>      &quot;parameters&quot;: {<br>        &quot;filter&quot;: {<br>          &quot;status&quot;: [&quot;initial&quot;, &quot;complete&quot;, &quot;due&quot;],<br>          &quot;dueBefore&quot;: &quot;date&quot;,<br>          &quot;titleContains&quot;: &quot;string&quot;<br>        }<br>      }<br>    },<br>    {<br>      &quot;name&quot;: &quot;updateTodo&quot;,<br>      &quot;tags&quot;: [&quot;mutating&quot;],<br>      &quot;parameters&quot;: {<br>        &quot;id&quot;: &quot;string&quot;<br>      }<br>    }<br>  ]<br>}</pre><p><strong>2. User activates agent mode:</strong><br>Visits <a href="https://todoapp.com/?agentmode=1">https://todoapp.com?agentmode=1</a></p><p><strong>3. User types:</strong></p><blockquote><em>“Push all incomplete todos due this week to next Monday, except anything with ‘urgent’”</em></blockquote><p><strong>4. WAP Engine executes:</strong></p><ul><li>Discovers listTodos and updateTodo tools</li><li>Calls listTodos with filters</li><li>Confirms with user: “Found 3 todos to reschedule”</li><li>Executes updateTodo for each item</li><li>Reports: “Rescheduled 3 todos to Monday, Dec 16”</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/416/1*gz0OHo4kHFFmMTLhRkJ9tw.png" /><figcaption><em>Figure 2: Multi-step workflow executed through natural language — </em><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/todo-management-example.md"><em>See Full Implementation</em></a></figcaption></figure><p>No DOM parsing. No computer vision. No accessibility tree navigation. No guesswork, just clean API calls and website functionality dynamically orchestrated by natural language.</p><h4>Two Modes for Different Needs</h4><p>WAP supports two interaction patterns:</p><p><strong>CoPilot Mode: </strong>Natural language operates on the current page’s UI elements.<br><strong><em>Best for:</em></strong> Filtering, sorting, form filling — interactions within a single page context.<br><strong><em>Example:</em></strong> On Amazon or Temu’s search page<br><strong><em>Setup Complexity:</em></strong> Super Simple</p><blockquote><em>User:</em> “Show me 30lb dumbbells under $100 with 4+ stars”<br><em>Agent:</em> Applies filters directly to the page’s search interface</blockquote><p><strong>Orchestrator Mode</strong>: Natural language triggers multi-step API workflows across the entire site.<br><strong><em>Best for:</em></strong><em> </em>Complex tasks requiring multiple API calls, data transformations, or cross-functional operations.<br><strong><em>Example:</em></strong><em> </em>Ordering<br><strong><em>Setup Complexity:</em></strong> Medium</p><blockquote><em>User:</em> “Reorder everything from my last order. If any items’ price has increased, ask me for confirmation. Use my rewards balance to pay if enough, otherwise, use my credit card.” <br><em>Agent:</em> Calls orders API -&gt; Filters results -&gt; Calls Product API -&gt; Ask Confirmation -&gt; Add to car -&gt; Calls payments API</blockquote><p>Sites can implement either or both modes depending on their needs.</p><h4>Why This Should Succeed</h4><p><strong>1. Zero Friction Adoption</strong></p><p><strong><em>For websites: </em></strong>Add one script tag. Publish one JSON manifest. Deploy Inference LLM. Wrapper endpoint. Enable agent mode. Done.</p><p><strong><em>For users: </em></strong>Use their current browser. Stay on the familiar website. Website automatically gains natural language (text and speech) interactions. Security and sessions preserved.</p><p><strong>2. Progressive Enhancement<br></strong>Start small, expand over time:</p><p><strong><em>Phase 1:</em></strong><em> </em>Enable natural language for your most common workflow (product search, order lookup)<br><strong><em>Phase 2:</em></strong><em> </em>Add more capabilities incrementally<br><strong><em>Phase 3:</em></strong><em> </em>Full conversational interface across your entire site</p><p>No big-bang rewrite needed.</p><p><strong>3. Economic Alignment</strong></p><p><strong><em>Website owners win: </em></strong>Differentiation (“AI-Ready”). Better UX without losing control. Maintain monetization and analytics. Future-proof as conversational interfaces become standard</p><p><strong><em>Users win: </em></strong>Faster task completion. Lower cognitive load. Natural interaction model</p><p><strong><em>Platforms win: </em></strong>Competitive advantage. New analytics and insights. Happy customers on both sides</p><p><strong>4. Platform Leverage<br></strong>If Shopify implements WAP, <strong>every Shopify store</strong> gets conversational interfaces automatically. Same with WooCommerce, Squarespace, Webflow, etc.</p><h4>Key Design Principles</h4><p>WAP is built on these core principles:</p><p><strong>1. Cooperative, Not Adversarial: </strong>Websites voluntarily expose functionality. They maintain control over their experience, data, and monetization.</p><p><strong>2. Secure by Default: </strong>WAP inherits the browser’s existing security model — same-origin policy, CORS, CSRF protection, content security policies. No new attack surfaces.</p><p><strong>3. Privacy Preserving: </strong>Your data flows directly from you to the website — just like filling a form manually. No third-party AI providers intercept your information.</p><p><strong>4. Reliable: </strong>Structured APIs with explicit contracts mean predictable, testable behavior. No brittle DOM parsing or computer vision guesswork.</p><p><strong>5. Performant: </strong>Direct API calls are 5–10x faster than alternatives that require page navigation, visual processing, and DOM manipulation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xrrsuOZZJBa_qFixoZ-4PQ.png" /><figcaption>WAP Design</figcaption></figure><h4>The Current Landscape</h4><p>While WAP represents a cooperative approach to agentic web interaction, it’s worth understanding the alternatives emerging in the market.</p><p><strong>Other Approaches to Agentic Browsing<br></strong>Several companies have launched agentic browsers that use <strong>DOM automation</strong> — analyzing web pages visually and simulating user clicks:</p><ul><li><strong>ChatGPT Atlas</strong> (OpenAI) — Browser integration with AI automation</li><li><strong>Perplexity Comet</strong> — AI-powered browsing assistant</li><li>Various browser extensions and automation tools</li></ul><p>These solutions share a common architecture: they parse the Document Object Model (DOM) or accessibility tree and automate interactions by simulating human behavior.</p><p><strong>The Fundamental Tradeoffs<br></strong>The DOM automation approach has significant implications:</p><p><strong><em>Security Concerns:</em></strong><br>DOM-based agents are vulnerable to prompt injection attacks. Brave Security’s research showed how malicious content on one website can influence AI behavior across all open tabs — a script on a shopping site could potentially manipulate the agent into accessing banking tabs or private emails. Traditional web security boundaries (same-origin policy, CORS) don’t apply when an AI operates with full user privileges across domains.</p><p><strong><em>Privacy Implications:</em></strong><br>These solutions send your requests and browsing context to third-party AI providers. Your natural language input (“find romantic hotels in Napa for December 14–16, budget $500/night”) is transmitted to the AI company’s servers before reaching the intended website. According to their privacy policies, this data may be retained for up to 30 days and used for model training.</p><p><strong><em>Reliability Challenges:</em></strong><br>DOM automation depends on visual parsing and accessibility trees. It fails on improperly labeled elements, complex SPAs, or custom components. It cannot interact with images, icons, or SVG elements lacking proper ARIA attributes. Also, because they do not understand the functionality of websites as intended by the owner, they involve guess-work and exploration, whereas WAP can be more targeted.</p><p><strong><em>Website Owner Friction:</em></strong><br>Sites invest heavily in curated experiences, conversion funnels, and monetization. DOM scraping bypasses ads, breaks analytics, and removes sponsored content. Amazon’s <a href="https://www.aboutamazon.com/news/company-news/amazon-perplexity-comet-statement">public response to Perplexity</a> highlights this tension — major platforms will resist approaches that undermine their business models.</p><h4>Why WAP Takes a Different Path</h4><p>WAP addresses these concerns through cooperative design:</p><p><strong>Security:</strong> Same-origin API calls using existing browser security model. No cross-domain prompt injection possible.</p><p><strong>Privacy:</strong> Data flows directly from user to website, never through third-party AI servers. Uses your existing session and cookies.</p><p><strong>Reliability:</strong> Explicit API contracts with structured data. No DOM parsing, no visual interpretation, no accessibility tree dependencies.</p><p><strong>Alignment:</strong> Website owners control the experience, maintain monetization, and preserve analytics. They can include ads, upsells, and sponsored content in agent responses.</p><p>The tradeoff? WAP requires site adoption. But we believe <strong>opt-in cooperation leads to sustainable, long-term success</strong> versus an adversarial arms race.</p><h3>Known Limitations</h3><p>WAP is intentionally scoped for practical adoption:</p><p><strong>Single-Domain Focus:</strong> WAP agents work within one website at a time. Cross-domain orchestration introduces massive complexity (authentication, payment flows, API coordination, security boundaries). Users can complete tasks on Site A, then move to Site B — just like browsing today.</p><p><strong>Requires Manifest:</strong> Sites must publish WAP manifests to participate. This is slower than adversarial automation but ensures security, reliability, and business model preservation.</p><p><strong>Trust Model:</strong> WAP requires trusting the website’s model endpoint — but this preserves the web’s existing trust model. When you share information with amazon.com, you’ve chosen to trust Amazon, not a third-party AI provider. For privacy-conscious organizations, WAP supports self-hosted model endpoints.</p><h3>What’s Next</h3><p>WAP is currently in the specification phase. We’re building:</p><ol><li><strong>Reference Implementation</strong> — Open-source WAP engine (NPM package)</li><li><strong>Sample Manifests</strong> — Real-world examples from e-commerce, SaaS, productivity apps</li><li><strong>Onboarding Tools</strong> — AI agent that crawls sites and generates draft manifests</li><li><strong>Developer Documentation</strong> — Integration guides, best practices, security guidelines</li></ol><p><strong>Early Access:</strong> We’re looking for early partners — especially platforms (Shopify, WooCommerce) and innovative SaaS companies.</p><h3>Complementary Goals (Out of scope for WAP)</h3><p>Investments/advancements in these directions would make WAP be more effective</p><ul><li>LLMs/SLMs particularly fine-tuned for the Browser, Agentic Browser interactions, User interfaces and capabilities. This could drastically reduce inference cost, and increase speed, efficiency, and reliability.</li><li>Privacy focused ready to deploy and configure inference WAP endpoint providers. These would make it easier for smaller players to get setup.</li><li>Browsers/W3C Specs to solve safe multi website interactions and build on-top of WAP.</li><li>On-device inferencing would even increase privacy</li></ul><p><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/live-demo.md">Try the Interactive Demo</a></p><h3>The Vision</h3><p>The web’s next chapter will be conversational. Users will expect to interact with websites through natural language, not just by clicking through predetermined paths.</p><p>The question is whether we build this future cooperatively — respecting website owners, protecting user privacy, and maintaining security — or through an adversarial arms race that benefits neither side.</p><p>WAP offers a path forward that works for everyone.</p><p><strong>Work-In-Progress Resources:</strong></p><p>Please note, these resources are still being worked on</p><ul><li><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/technical-design.md">Complete Technical Specification</a></li><li><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/todo-management-example.md">Todo Management Example (Full Implementation)</a></li><li><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/amazon-copilot-example.md">Amazon CoPilot Mode Example</a></li><li><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/solutions-comparison.md">WAP vs. Current Solutions (Detailed Comparison)</a></li><li><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/adoption-strategy.md">Adoption Strategy &amp; Economics</a></li><li><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/security-model.md">Security Model Deep Dive</a></li><li><a href="https://github.com/midearth-labs/web-agent-protocol/blob/main/v0/live-demo.md">Interactive Demo</a></li></ul><p><strong>References:</strong></p><ol><li><a href="https://www.malwarebytes.com/blog/ai/2025/09/ai-browsers-or-agentic-browsers-a-look-at-the-future-of-web-surfing">AI browsers or agentic browsers: a look at the future of web surfing</a></li><li><a href="https://www.cyberhaven.com/blog/browser-agent-security-risk-chatgpt-atlas">ChatGPT Atlas: Browser Security Risks</a></li><li><a href="https://openai.com/index/building-chatgpt-atlas/">Building ChatGPT Atlas (OpenAI)</a></li><li><a href="https://brave.com/blog/comet-prompt-injection/">Comet Prompt Injection Vulnerability (Brave)</a></li><li><a href="https://www.aboutamazon.com/news/company-news/amazon-perplexity-comet-statement">Amazon’s Response to Perplexity Comet</a></li></ol><p><strong>About the Author:</strong> I’m Oladipo Fasoro, the Lead Developer and Co-Founder at MidEarth Labs, building open-source frameworks for rapid AI-based software prototyping. After 12+ years in software engineering (including time at AWS working on systems serving millions), I’m focused on making AI practical and safe for real-world applications.</p><p>Connect with me on <a href="https://www.linkedin.com/in/dfasoro/">LinkedIn</a> | Follow the project on <a href="https://github.com/midearth-labs/web-agent-protocol">GitHub</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d45520d3388e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why “success” with AI coding agents will not automatically translate to enterprise AI agents.]]></title>
            <link>https://medium.com/@chilled_techie/why-success-with-ai-coding-agents-will-not-automatically-translate-to-enterprise-ai-agents-2206ecbb8034?source=rss-6d5b931047f2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2206ecbb8034</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[enterprise-technology]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[cursor]]></category>
            <dc:creator><![CDATA[Oladipo Fasoro]]></dc:creator>
            <pubDate>Wed, 05 Nov 2025 01:17:14 GMT</pubDate>
            <atom:updated>2025-11-05T01:30:58.010Z</atom:updated>
            <content:encoded><![CDATA[<p>Coding agents (Claude, Cursor, Kiro, etc), and customer support agents are the popular use-cases that showcase agentic AI success. With every shiny agentic demo, there is a growing confidence that because we see “impressive” progress with coding assistants and coding agents, the next natural step is autonomous enterprise agents running operational workflows. I believe this assumption needs careful examination.</p><h3>My Agentic Coding Play-Loop</h3><p>My favourite pastime when doing agentic coding in TypeScript is watching how Cursor carries out its “chain of thought” as it autonomously tries to fulfill the request I give it. First the agent “asks” itself: should I run find, grep, or ls to locate this file/string? It tries a shell tool. Then perhaps it attempts a code mutation, types a method, and runs tsc or npm build or eslint. It fails with a type error. Then it backtracks: re-reads the file, mutates again, maybe casts something to any (“fine, we’ll remove strict typing for now”) and finally declares “success” with a verbose summary of the implementation it generated.</p><p>We’ve all been there: the code compiles, tests pass (maybe), the agent high-fives itself. But the pattern is instructive — it shows how the coding agent relies on deterministic tooling: compile-time errors, type systems, repeatable shell commands, isolated workspace state. And it works because the environment is built for that kind of loop.</p><p>It’s precisely this observation — the joy of watching the loop “succeed” in a sandboxed dev workspace — that led me to write this article. Because what works so cleanly without consequence in the developer workstation might not hold when you transfer the same assumptions into enterprise systems. Notwithstanding, having no errors does not even imply the coding agent actually fulfilled your request as intended.</p><p>Coding agents “succeed” today not only because models are improving, but because the software development environment is uniquely structured for automation. It has properties that most real-world enterprise systems do not yet offer. For example:</p><p><strong>1. Deterministic feedback loops</strong><br> Linters, compilers, test suites, and type systems give clean, structured, machine-actionable error signals.</p><p><strong>2. Reliable state and isolation</strong><br> The code workspace is a single-agent sandbox. There are no concurrent writes from other actors, no external mutation, and Git provides history, checkpoints, and rollbacks.</p><p><strong>3. Predictable side-effects</strong><br> File edits, builds, and test runs have consistent behavior. The environment behaves like an implicit transaction system: you can revert, retry, or branch without real world consequences.</p><p><strong>4. Documentation and examples in training data</strong><br> Coding tools, compilers, and frameworks have standardized error formats, structured outputs, and consistent API documentation. These patterns exist in large volumes in model training corpora. Enterprise systems rarely provide this level of consistent, machine-readable structure.</p><p>In short, coding agents thrive because the ecosystem already satisfies many of the conditions that make automation feasible: deterministic environments, clear correctness signals, isolated state, reversibility, and standardized feedback structures.</p><h3>Now compare this to real enterprise production systems.</h3><p>Enterprise environments are distributed, stateful, multi-actor, and tied to real customers and financial systems. They have partial failures, non-deterministic timing, eventual consistency, and side-effects that cannot simply be rolled back with a git reset. Interfaces and logs are mostly built for human operators, not agents. Retry semantics, idempotency guarantees, compensating actions, isolation levels, consistency properties, and blast-radius controls vary widely.</p><p>These pose real distributed systems challenges and understanding how to wrangle these to produce reliable and scalable systems is a major hallmark of <strong>human</strong> technical leadership in system design, and the same reasons change management, observability, incident response, and rollback strategy exist. When we automate operational behaviour similarly, we are effectively building an autonomous distributed systems actor across multiple systems. That means the same rigour must apply.</p><h3>A Practical Example</h3><p>Imagine an enterprise agent whose plan of action is: “Approve a refund request for a customer, update the billing system, send the funds, email the customer, and log the transaction for audit.”</p><p>In this enterprise scenario you must ask: Are the various subsystems (billing, payments, audit logs, email service) strongly consistent or otherwise do they expose well defined and documented contracts for eventually consistent flows, do they expose compensating operations? Can you roll back the payment if the email fails? Is the refund operation idempotent (what if the agent triggers it twice)? What happens if the billing service is eventually consistent and the audit log lags? What happens when the agent explores multiple solutions, can you completely rollback and restart from a clean slate?</p><p>So while coding agents are an exciting milestone, treating them as a proof point that autonomous enterprise agents are ready for broad deployment is premature. The environments are fundamentally different.</p><p>Technical leaders in organizations that understand this early should ask themselves whether they are <em>actually ready</em> to deploy AI-agents and if the investment is tied to identifiable customer value, rather than getting carried away by marketing hype or FOMO. They should ensure that what they build is what their customers really want. And if they do decide to deploy agentic AI, that they will deploy autonomy safely, with clear and practical engineering judgement, preserve customer trust, and avoid being the cautionary tale as some already are.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BwWnws_Ev8jOeQ8BvXFwSQ.png" /></figure><h3>References</h3><ul><li>Six lessons from production deployment of AI Agents (<a href="https://www.mckinsey.com/capabilities/quantumblack/our-insights/one-year-of-agentic-ai-six-lessons-from-the-people-doing-the-work">mckinsey</a>)</li><li>Cursor IDE hallucinates Policy. (<a href="https://news.ycombinator.com/item?id=43683012">hackernews</a>)</li><li>Writing effective tools for agents — with agents (<a href="https://www.anthropic.com/engineering/writing-tools-for-agents">anthropic.com</a>)</li><li>Building effective agents. (<a href="https://www.anthropic.com/research/building-effective-agents">anthropic.com</a>)</li></ul><h3>About Me</h3><p>I am Oladipo Fasoro, Ex-AWS Engineer, deeply engaged in research on AI, AI ethics, and autonomous systems. You can follow me on Medium @ <a href="https://medium.com/u/6d5b931047f2">Oladipo Fasoro</a>, Substack @ <a href="https://chilledtechie.substack.com/">Oladipo Fasoro</a> or LinkedIn @ <a href="https://www.linkedin.com/in/dfasoro/"><strong>dfasoro</strong></a>. I welcome connection and conversation on responsible generative AI and how we build safe, trustworthy technology together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2206ecbb8034" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>