<?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 Stanley Joseph on Medium]]></title>
        <description><![CDATA[Stories by Stanley Joseph on Medium]]></description>
        <link>https://medium.com/@stanley.joseph_22065?source=rss-a0af501420db------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*dKF0QohAIK5EcglC</url>
            <title>Stories by Stanley Joseph on Medium</title>
            <link>https://medium.com/@stanley.joseph_22065?source=rss-a0af501420db------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 20:31:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@stanley.joseph_22065/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[We abstracted the LLM provider, then deliberately un-abstracted it]]></title>
            <link>https://medium.com/techunfiltered-ayata/we-abstracted-the-llm-provider-then-deliberately-un-abstracted-it-d4ff1ede176c?source=rss-a0af501420db------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4ff1ede176c</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ayatacommerce]]></category>
            <category><![CDATA[aws-strands]]></category>
            <category><![CDATA[amazon-bedrock]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Stanley Joseph]]></dc:creator>
            <pubDate>Mon, 22 Jun 2026 10:42:00 GMT</pubDate>
            <atom:updated>2026-06-22T10:42:00.074Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tJri0geJ9kyUHymmCiNQzg.png" /></figure><blockquote>This is part 4 of a series on building an enterprise AI shopping concierge. We trace one product through four ground-up rebuilds and document what each rebuild broke and what it fixed, with the engineering shown rather than asserted.</blockquote><blockquote>The AI Concierge is a multi-agent assistant for online retail. Instead of handing the shopper a list of results and walking away, it works out what the shopper actually needs, then recommends and explains. Specialist agents cover advice, search, cart, and support behind a typed contract, alongside the platform controls that make an agent safe to run in production: guardrails, cost limits, and an audit trail.</blockquote><blockquote>In this part: why we built a clean interface so the concierge could run on more than one model vendor, why the next rebuild tore half of it out on purpose, and why that made the system simpler instead of more fragile.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hXZ9TlwrB03xBdyYC93qNQ.png" /></figure><p>New here? Read the <a href="https://medium.com/techunfiltered-ayata/building-an-enterprise-ai-shopping-concierge-the-series-7e08bf8ddb44">series index</a>, or go back to <a href="https://medium.com/techunfiltered-ayata/why-semantic-search-kept-burying-the-exact-match-d811a605cc0a">part 3</a>.</p><p>There is a piece of advice every engineer absorbs early: do not tie yourself to one vendor. Put an interface in front of the thing that might change. Keep your options open.</p><p>It is good advice. It is also dangerous when it stops sounding like a choice.</p><p>When we built the multi-cloud version of the concierge, we did the textbook thing. We put a clean provider interface in front of the language model, so the agent code could run on more than one vendor without knowing which model was answering. It was good engineering. Every reviewer would have approved it.</p><p>The next rebuild deleted half of it and demoted the rest. On purpose.</p><p>That is the story in this part: when a portability abstraction earns its keep, when it starts taxing the system around it, and what actually happens to vendor lock-in when the product bet changes. The short version is the rule we now carry forward: an abstraction is a bet on a future you cannot see yet. It is worth its cost only while that bet is still live.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eNPm2F-zxVK3MoftYTnkIA.png" /><figcaption><em>One interface, two real vendors, and the places where “they look identical to the caller” stopped being true. The leaks are not bugs. They are the bill for the bet.</em></figcaption></figure><h3>We built the right abstraction</h3><p>Go back one rebuild. The multi-cloud version existed to prove a specific claim to enterprise buyers: this concierge was not welded to one cloud. If a buyer was aligned with one vendor, we could run there. If another buyer was aligned somewhere else, we could run there too.</p><p>That claim had to be true in code, not just on a slide.</p><p>So we wrote one interface and put every model vendor behind it. A provider could chat, stream a chat, embed text, embed an image, describe an image, and report whether it supported vision. The interface described itself as “the seam between agent code and the underlying LLM SDK so a future provider swap (or framework swap) is one bounded change.” It also made the important promise: “no SDK objects leak past the provider boundary.”</p><p>That promise matters. Agent and service code spoke in our neutral types: Message, ToolDef, LLMResponse, Embedding. Behind that interface sat two real cloud providers, plus a cheap dev provider and a mock for tests. A factory picked the provider from tenant config. A single agent could even override the tenant default.</p><p>This was not cargo-cult abstraction. The option was real. The bet had value. While the question was “which cloud will this need to run on,” the interface earned its carrying cost.</p><blockquote><strong>Why it matters to the business.</strong> Optionality is something you pay for every month whether or not you use it. That premium is worth paying while the option is live, especially if a deal can hinge on a customer’s preferred cloud. The mistake is not buying the option. The mistake is forgetting it has a renewal date.</blockquote><h3>Then it started leaking</h3><p>The abstraction only works if the vendors behave alike enough that the caller cannot tell which one sits underneath. They did not.</p><p>We can point to the leaks because they were not theoretical. They were sitting in the adapter code.</p><p>The clearest leak was image embedding. The interface said embed_image could accept bytes or a URL string. The Gemini adapter honoured both: hand it a URL and it builds the right SDK part. The Bedrock adapter could not. Hand it a URL and it raised NotImplementedError with the reason in the code: URL fetching was not supported.</p><p>That is the failure mode of a leaky abstraction. A caller reads the interface, trusts the contract, writes code that works on one provider, and discovers later that the same contract throws on another.</p><p>Text embedding leaked too. It looked like the most interchangeable operation in the system: text in, vector out. Inside the Bedrock adapter, it still had to branch by model family because Cohere and Titan used different request and response shapes. Same cloud, same public method, different wire formats. Gemini did not need the same branching. The interface made the two sides look equal by making the adapters quietly unequal.</p><p>Then came the small cuts. Gemini emitted a finish signal on every streaming chunk and only meant it on the last one, so the adapter filtered false finishes. Bedrock signalled finish once. Gemini had no real tool-call IDs, so the adapter invented them. Claude returned opaque IDs that passed through unchanged.</p><p>None of this made the interface bad. Some differences were absorbed cleanly. System prompt placement and tool schema naming stayed hidden inside each adapter, exactly as they should. But the pattern was clear: the abstraction was not removing vendor difference. It was moving vendor difference into places fewer people looked.</p><blockquote><strong>Why it matters to the business.</strong> A leaky abstraction costs twice. You maintain two real code paths underneath, and you maintain the fiction that there is only one. Engineers then build against the fiction. The bugs show up later, usually on the provider you tested least.</blockquote><h3>The bet changed</h3><p>The AWS reference was not a patch on the multi-cloud baseline. It was a fork with a different job.</p><p>The baseline was built to prove “we can run anywhere.” The AWS reference was built to win a different room: an enterprise architecture review where the stronger story was “every line of code here serves this stack.” The decision record says the quiet part plainly: a single-cloud reference lands better in architecture review than a multi-cloud demo, so the fork stripped the other cloud paths until every line served the AWS narrative.</p><p>Those are two different product bets.</p><p>In the first bet, the unknown vendor future was worth keeping open. In the second, the future was known enough that keeping the option open had become waste. The multi-cloud abstraction was not wrong and then right. It was right for the baseline, and collapsing it was right for the reference. The code quality did not flip. The wager underneath it resolved.</p><h3>What we deleted</h3><p>Un-abstracting was mostly deletion, which is the most undervalued kind of engineering work.</p><p>Two providers left the repo. The Gemini adapter was more than four hundred lines. The dev-mode provider was another four hundred and sixty-three. Both were removed. The factory that used to choose between vendors became a boot gate: ask for bedrock and you get Bedrock; ask for anything else and startup fails with a loud error: Only &#39;bedrock&#39; is supported in the AWS-only fork.</p><p>That failure mode is deliberate. A tenant config that still names a removed provider should not limp along on a silent default. It should fail at boot, because a misconfiguration that announces itself on startup is cheaper than one that hides until a shopper hits the path nobody tested.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fqNESy5mS_ClFv300KDdHg.png" /><figcaption><em>Left, the bet: a factory choosing between three vendors, each with its own adapter and its own leaks. Right, the bet resolved: one boot gate, and the seam relocated to the framework and a single audit choke point.</em></figcaption></figure><p>There is one wrinkle, and it matters because tidy stories hide useful truth. We did not delete the home-grown interface completely. A few utility paths still call through it, and the single Bedrock implementation still satisfies those calls. What changed is that the interface no longer represents a live vendor choice. It went from a real option to a formality with one option on the menu.</p><p>The abstraction was not killed. It was demoted.</p><blockquote><strong>Why it matters to the business.</strong> Every provider path you remove is a path nobody has to test on every release, a set of credentials nobody has to rotate, a dependency nobody has to patch, and a slide nobody has to defend when a security team asks what all of it is for. Deleting code is not cleanup. It is product work.</blockquote><h3>The seam moved</h3><p>Here is the right objection: did we just weld ourselves to one vendor?</p><p>No. We moved the seam.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J4Ybp0IgBjx7_A1tL_RhVg.png" /><figcaption><em>Where a model call used to flow, and where it flows now. The boxed seam moves off our adapter and into the framework, while the audit-and-cost interceptor appears on the agent path.</em></figcaption></figure><p>For the Strands agent runtime, the home-grown provider is no longer in the model path. Each agent is built from a YAML manifest, resolves a model tier such as tier:fast or tier:flagship to the region-correct Bedrock invoke target, constructs Strands&#39; native BedrockModel, and hands that model to the agent. The vendor boundary now sits in framework code rather than in our adapter code.</p><p>That is a smaller claim than “we still have the same portability,” and it is the more honest one. If a future product needs a second vendor again, the work is not zero. But it is bounded, and it starts from a cleaner place than the old abstraction: the agent path has one model boundary, owned by the framework, and no dead vendor branches pretending to be live.</p><p>The other thing we gained was a governance surface.</p><p>Because the agent path now makes one shape of model call, Strands lifecycle hooks can see those calls consistently. The after-model-call hook feeds the gateway that records token usage, cost, and audit rows for Strands agent calls. The same hook stack also supports budget commits, tool audit, routing visibility, and the Cogitator overlays. Service calls that still sit outside the Strands loop are handled separately where they need explicit metering, which is exactly the point: the agent runtime has one predictable stream, and the exceptions are visible as exceptions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RIBpyaJ74L67C4LXMgqMTg.png" /><figcaption><em>One Strands agent call, end to end. The model seam is the model object. The governance seam is the hook firing into the gateway.</em></figcaption></figure><p>This is the part that the usual “avoid lock-in” advice underprices. A multi-vendor design does not prevent governance, but it makes governance a matrix. Each provider needs its own edge cases for usage, pricing, audit payloads, retries, and guardrails. Standardising on one vendor turned that matrix into one primary interceptor on the agent path. We gave up hypothetical flexibility and gained the control surface an enterprise buyer actually asks about.</p><h3>The ghost we left behind</h3><p>The demoted interface left a fingerprint.</p><p>One utility service still describes itself as “provider-neutral.” It still routes through the factory, as it did when the factory represented a real choice. But the factory now has one provider it can return.</p><p>Nothing breaks. That is why these fossils survive. The code faithfully performs a choice that no longer exists, and the comment preserves the old bet in amber.</p><p>That small leftover is useful because it makes the larger question concrete: how much abstraction in a mature system is still a live bet, and how much is a hedge against a future that already arrived? Most codebases carry this kind of fossil. We happened to catch one with the word neutral still painted on the side.</p><h3>The lesson</h3><p>Here it is, stated plainly: an abstraction is a bet on an unknown future, not a virtue you collect by having more interfaces. Match the abstraction to the bet you are actually making. While the bet is live, pay the carrying cost. When the bet resolves, collapse it, demote it, or move the seam to a layer better suited to own it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QkchXxZmuGqVa_yQ3Vra5w.png" /><figcaption><em>A rule you can carry to the next abstraction. The question is never “is an interface good engineering,” it is “is the bet still live, and is this still the best place to hold the seam.</em></figcaption></figure><p>What would we do differently? We would have written the renewal date on the abstraction when we built it. The multi-cloud interface was correct, but nothing in it recorded the condition under which it should be retired. So part of it survived into a product whose bet had changed, and we found the fossil instead of being reminded by it.</p><p>The decision this part rests on, and what it cost:</p><blockquote><strong>The decision.</strong> Delete the multi-vendor providers, reduce the provider factory to a Bedrock-only boot gate, and let the agent runtime’s model seam live in the framework instead of our own abstraction.</blockquote><blockquote><strong>Why.</strong> The multi-cloud bet had resolved into a single-cloud product. A portability abstraction that no longer protected a live option had become carrying cost, and collapsing it unlocked a cleaner audit-and-cost surface for the Strands agent path.</blockquote><blockquote><strong>What it cost.</strong> Live multi-vendor portability, given up deliberately, plus a demoted interface that still lingers for utility calls with the word “neutral” fossilised in its comments. The exit is not gone, but it is no longer pretending to be free.</blockquote><p>The textbook says never tie yourself to one vendor. The textbook is describing a bet, not a law. When you know which way the bet has resolved, the useful thing is to commit, delete the hedge, and make sure the seam moved rather than died.</p><h3>The architecture after part 4</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cz_IhnaUsnbh6KCNE5Rlhg.png" /><figcaption><em>Part 4 collapsed the provider to a single vendor and relocated the agent’s model seam onto the framework. The gateway where every agent call now converges is ghosted here, because it is the subject of the parts ahead.</em></figcaption></figure><p><strong>Next in the series: we gave every agent a budget, and the bill stopped being a surprise.</strong> Committing to one vendor put the agent runtime through a single model path. In the next part we stand in that path and start counting: per-session and per-tenant budgets, a live spend ledger, and what it takes to make an AI system that cannot quietly run up a bill nobody approved.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4ff1ede176c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/techunfiltered-ayata/we-abstracted-the-llm-provider-then-deliberately-un-abstracted-it-d4ff1ede176c">We abstracted the LLM provider, then deliberately un-abstracted it</a> was originally published in <a href="https://medium.com/techunfiltered-ayata">TechUnfiltered@Ayata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why semantic search kept burying the exact match ?]]></title>
            <link>https://medium.com/techunfiltered-ayata/why-semantic-search-kept-burying-the-exact-match-d811a605cc0a?source=rss-a0af501420db------2</link>
            <guid isPermaLink="false">https://medium.com/p/d811a605cc0a</guid>
            <category><![CDATA[semantic-search]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[aws-opensearch]]></category>
            <category><![CDATA[agentic-commerce]]></category>
            <category><![CDATA[ayatacommerce]]></category>
            <dc:creator><![CDATA[Stanley Joseph]]></dc:creator>
            <pubDate>Sat, 06 Jun 2026 21:31:38 GMT</pubDate>
            <atom:updated>2026-06-06T21:34:15.912Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vkd397uj6gNRGPNJVkQvew.png" /></figure><blockquote>This is part 3 of a series on building an enterprise AI shopping concierge. We trace one product through four ground-up rebuilds and document what each rebuild broke and what it fixed, with the engineering shown rather than asserted.</blockquote><blockquote>The AI Concierge is a multi-agent assistant for online retail. Instead of handing the shopper a list of results and walking away, it works out what the shopper actually needs, then recommends and explains. Specialist agents cover advice, search, cart, and support behind a typed contract, alongside the platform controls that make an agent safe to run in production: guardrails, cost limits, and an audit trail.</blockquote><blockquote>In this part: why vector search alone kept hiding the one product the shopper actually asked for, and what fixing it taught us about relevance as a business surface.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G1DXHDQYavPjYeVw03MPeg.png" /><figcaption>New here? Read the <a href="https://medium.com/techunfiltered-ayata/building-an-enterprise-ai-shopping-concierge-the-series-7e08bf8ddb44">series index</a>, or go back to <a href="https://medium.com/techunfiltered-ayata/one-engine-a-different-store-a458285fbb21">part 2</a>.</figcaption></figure><p>A shopper in our specialist hobby store (Vertical B in our internal shorthand) types the name of one specific item. Not a category, not a vibe. A named thing they have already decided to buy. The kind of request that should be the easiest search a store ever has to answer, because the shopper has done all the work of knowing what they want.</p><p>The assistant searched, and the item the shopper named was not on the first page. It was not on the second. Three products that meant something similar sat at the top, confident and wrong, and the thing the shopper actually asked for was buried below them.</p><p>This is the failure that taught us a lesson everyone building with embeddings learns eventually, usually the expensive way: semantic search is very good at understanding what a shopper means, and quietly bad at finding exactly what they named. Getting from one to the other is not a model upgrade. It is engineering, and it is the kind of engineering that maps straight onto whether the shopper buys or leaves.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xcyK35lTd_txaO_zMAXUDg.png" /><figcaption><em>Same query, three rankings. Semantic understands meaning and blurs exact names; keyword floods on a shared word; only the rebalanced hybrid puts the exact item first.</em></figcaption></figure><h3>Why embeddings blur the thing you named ?</h3><p>An embedding turns a product into a point in a 1024-dimensional space, using the same Bedrock Titan text-embed model for the query and for every item in the catalogue. Two things that mean something similar land near each other. That is the whole magic, and it is genuinely powerful: a shopper can ask for “something warmer for a wet climb” and get sensible results even though no product description contains those words.</p><p>But meaning is exactly the wrong lens for an exact identifier. A model number, a precise product name, a specific edition: these are tokens that have to match, not concepts that have to be near. To an embedding, the exact item the shopper named and three near-cousins all look about equally close, because they mean almost the same thing. The one signal that should dominate, the literal name, gets averaged into a cloud of meaning.</p><blockquote><strong>Why it matters to the business.</strong> This failure is silent. Nothing errors. No alert fires. The shopper sees a confident page of results, decides you do not stock the thing they wanted, and leaves. You never see the lost sale, because from the system’s point of view nothing went wrong. Relevance failures are churn you never measure.</blockquote><h3>Going hybrid: one query, two clauses, one trip</h3><p>The obvious fix is to add keyword search back alongside the vectors, and that instinct is right. The interesting part is how you combine them without making the system slow or complicated.</p><p>We do it in a single round-trip. Every search is one query to the cluster, a bool-should with two clauses inside it: a k-NN clause over the embedding field for semantic similarity, and a multi_match clause over name, description, brand, category, and tags for literal matching. The cluster scores both, ranks the union, and hands back one ordered list. There is no second call, and there is no in-process merge step where our code stitches two result sets together. The k-NN clause asks for k of max(limit times two, ten) neighbours so there is enough depth to re-rank; a hit on either clause is enough to qualify, because the minimum number of clauses a result must match is one.</p><p>Earlier in the product’s life that blending happened after the fact, in our own code, with a fixed weighting and a small bump for items that appeared in both lists. Pushing it into a single query on the managed cluster is what let us delete the merge step entirely and let the cluster do the ranking.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KltYjF1u7Rke3PTOsH7ilA.png" /><figcaption><em>Two signals, one trip. The query is embedded once and matched literally at the same time; the cluster ranks the union. The weights on each clause are where relevance is won or lost.</em></figcaption></figure><blockquote><strong>Why it matters to the business.</strong> One round-trip is what lets the assistant feel instant. Search sits in the middle of every conversation the concierge has, so its latency is the conversation’s latency. A two-call merge would have been simpler to write and slower on every single turn, paid by the shopper in milliseconds they can feel.</blockquote><h3>The trap: two scores that do not share a scale</h3><p>Going hybrid fixed the obvious problem and introduced a subtle one that is much harder to spot, because the search still returns results and they still look plausible.</p><p>Here is the trap. The cluster sums the raw, unnormalized scores of the two clauses. But the two clauses are not on the same scale. A semantic cosine score sits in a bounded range, roughly zero to two. A keyword BM25 score is unbounded: a strong literal match on a common token can score arbitrarily high. So when you simply add them, the keyword clause does not contribute to the ranking, it dictates it.</p><p>We hit this in the worst way for a catalogue like a hobby store’s, where many unrelated products share a common word in their names. A shopper searched for a specific item whose name happened to contain one of those shared words. That single token lit up the keyword score on dozens of unrelated products, every one of them scoring higher than the item the shopper actually wanted. The search confidently returned a wall of things that shared one word and buried the right answer underneath them. Our original per-field boosts made it worse: we had boosted the name field by three and the brand field by two, which is sensible in a pure keyword engine and actively harmful once an unbounded score is already swamping a bounded one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N26oqp7cagsMCfVsWtkygQ.png" /><figcaption><em>The bug and the fix. Before, one unbounded keyword match outscores real intent. After, the keyword clause is scaled down and the semantic clause up, so intent wins and exact matches still contribute.</em></figcaption></figure><blockquote><strong>Why it matters to the business.</strong> A confident wrong answer is worse than no answer. An empty result page tells the shopper to rephrase. A full page of confident, wrong results tells them you do not have what they want, in a voice that sounds certain. The system was at its most damaging exactly when it looked like it was working.</blockquote><h3>The boring fix, on purpose</h3><p>There is a textbook fix for mismatched score scales: a normalization pipeline that rescales each clause before combining them. It is the technically correct answer, and we did not use it.</p><p>We did not use it because it would not behave the same everywhere. Pipeline support differs between the OpenSearch container our engineers run locally and the managed cluster we run in production. A fix that normalizes beautifully on a laptop and behaves differently in production is not a fix, it is a latent incident. So we took the unglamorous path instead. We scaled the whole keyword clause down with a boost of 0.3, scaled the semantic clause up with a boost of 2.0, and dropped the per-field name and brand boosts so no single field could overpower the rest. Conservative constants, chosen to behave identically on the local container and on the managed cluster.</p><p>The result is that semantic intent leads and exact lexical matches still contribute, instead of one drowning the other. A test locks the behaviour in so a future change cannot quietly undo it: the semantic clause must outweigh the keyword clause, the keyword boost must stay low, and no per-field boost may creep back in.</p><blockquote><strong>Why it matters to the business.</strong> Portability is a business decision wearing an engineering costume. The clever fix optimizes one environment; the boring fix is the same in every tenant’s production cluster and on every engineer’s laptop. When you ship the same system to many customers, predictable-everywhere beats optimal-somewhere, because the cost of a relevance regression in a live store is paid in that customer’s revenue and trust, not in a benchmark.</blockquote><h3>The cost knob we deliberately left off</h3><p>There is one more relevance lever in the codebase that we deliberately keep switched off: optional LLM query expansion. The idea is to rewrite a shopper’s phrase into a handful of synonyms, so that “warmer in monsoon” could reach “down jacket, waterproof shell” before the keyword pass runs.</p><p>We built the capability behind a per-tenant switch and left the switch off by default, because the audit was unkind to it. On a well-named catalogue, the extra model call it adds was measured at around five seconds per search for a negligible improvement in what came back. Five seconds is not a tuning detail in a conversation, it is the difference between an assistant that feels alive and one that feels broken. So expansion stays off, a switch meant to be flipped only for a store whose shoppers describe things in words that diverge sharply from the catalogue’s own language.</p><blockquote><strong>Why it matters to the business.</strong> Relevance spend is a dial, not a default tax. The honest move was to measure the feature, find it was not earning its latency for most stores, and make it opt-in rather than leave a five-second cost running for everyone to feel sophisticated. Features you can measure and switch off per customer are how a demo becomes a product.</blockquote><h3>Moving search onto a managed cluster</h3><p>Underneath all of this, search moved onto Amazon OpenSearch Serverless, with one product index per tenant. The application talks to it through a signed, pooled connection, and crucially, when the cluster is not configured at all, search degrades to an empty result list instead of throwing. That sounds like a small thing. It is what lets an engineer run the entire concierge on a laptop with no cloud account, and it is locked by a test so nobody breaks it.</p><p>Each tenant’s index stores the product vectors as an approximate-nearest-neighbour field using cosine similarity, and a migration script bootstraps or rebuilds an index idempotently: it reads the catalogue, reuses cached embeddings or regenerates them on demand, and bulk-loads in batches. The mapping even detects the embedding dimension at load time, so a tenant on a different embedding model gets a correct index without a code change.</p><blockquote><strong>Why it matters to the business.</strong> This is the build-versus-buy line drawn deliberately. We did not run our own search infrastructure; we rented a managed cluster and spent our engineering on the part that is actually our product, the per-tenant tuning and the relevance logic on top. The graceful degradation is what keeps the cost of trying the system, for a developer or a prospect, at zero.</blockquote><h3>The lesson</h3><p>Here it is, stated plainly: AI search is not the embedding. The embedding is the easy part, the part that gets you a convincing demo. The hard part is everything that makes it actually find what a real shopper named: fusing semantic and literal signals, noticing that their scores live on different scales, and choosing a fix that holds the same in every environment you ship to. Relevance is engineered, not summoned, and on a storefront it is engineered revenue.</p><p>What would we do differently? We would have tested with exact-identifier queries from the first day, alongside the meaning-rich ones that make embeddings look magical. The score-scale trap was invisible precisely because our early test queries were the ones semantic search is best at. The bug lived in the queries we were not asking, which were the queries the most decided, most ready-to-buy shoppers ask first.</p><p>The decision this part rests on, and what it cost:</p><blockquote><strong>The decision.</strong> Fuse semantic and keyword search in one round-trip, and fix the score-scale clash with conservative reweighting rather than a normalization pipeline.</blockquote><blockquote><strong>Why.</strong> Embeddings alone bury exact matches, and the clever fix would behave differently across local and managed clusters. Predictable-everywhere relevance protects the shopper’s trust in a live store.</blockquote><blockquote><strong>What it cost.</strong> Hand-tuned boost constants that need a regression test to defend, and a deliberate ceiling on cleverness in exchange for portability.</blockquote><p>The shopper who names a product is telling you they are ready to buy. The least you can do is put it first.</p><h3>The architecture after part 3</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RBfFIsgzQZGUk9i9gsXcwg.png" /><figcaption><em>Part 3 hardened search and moved it onto a managed cluster. The engine around it did not change, and the platform controls are still ahead of us.</em></figcaption></figure><p><strong><em>Next in the series: we abstracted the LLM provider, then deliberately un-abstracted it.</em></strong><em> The multi-cloud baseline could run on more than one model vendor behind a clean provider interface. The AWS reference threw that flexibility away on purpose. We get into when a portability abstraction earns its keep, when it quietly taxes everything you build, and why committing to one provider made the system simpler and cheaper to reason about</em>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d811a605cc0a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/techunfiltered-ayata/why-semantic-search-kept-burying-the-exact-match-d811a605cc0a">Why semantic search kept burying the exact match ?</a> was originally published in <a href="https://medium.com/techunfiltered-ayata">TechUnfiltered@Ayata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One Engine, a Different Store !]]></title>
            <link>https://medium.com/techunfiltered-ayata/one-engine-a-different-store-a458285fbb21?source=rss-a0af501420db------2</link>
            <guid isPermaLink="false">https://medium.com/p/a458285fbb21</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ayatacommerce]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[agentic-commerce]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <dc:creator><![CDATA[Stanley Joseph]]></dc:creator>
            <pubDate>Sat, 06 Jun 2026 18:16:10 GMT</pubDate>
            <atom:updated>2026-06-06T18:16:10.152Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7pnkwn-Uz_tzhNFLvGYbFA.png" /></figure><blockquote>This is part 2 of a <a href="https://medium.com/techunfiltered-ayata/building-an-enterprise-ai-shopping-concierge-the-series-7e08bf8ddb44">series</a> on building an enterprise AI shopping concierge. We trace one product through four ground-up rebuilds and document what each rebuild broke and what it fixed, with the engineering shown rather than asserted.</blockquote><blockquote>The AI Concierge is a multi-agent assistant for online retail. Instead of handing the shopper a list of results and walking away, it works out what the shopper actually needs, then recommends and explains. Specialist agents cover advice, search, cart, and support behind a typed contract, alongside the platform controls that make an agent safe to run in production: guardrails, cost limits, and an audit trail.</blockquote><blockquote>In this part: how we moved the whole engine to a completely different store, and what it proved about the boundary.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cbhHEFRc9cW8cZjwttGvkA.png" /></figure><p>New here? Read the <a href="https://medium.com/techunfiltered-ayata/building-an-enterprise-ai-shopping-concierge-the-series-7e08bf8ddb44">series index</a>, or go back to <a href="https://medium.com/techunfiltered-ayata/the-advisor-not-the-search-box-7b4fdf5fdb3b">part 1</a>.</p><h3>The claim we had to prove</h3><p>A reference architecture is only as good as its second deployment.</p><p>We had built the concierge against an outdoor-equipment retailer (Vertical A in our internal shorthand). The advisor assessed before it answered, the coordinator routed to specialists, the typed contract kept actions honest. It worked, and it demoed well. And every time we presented it, we made the same claim out loud: this engine is vertical-agnostic. The domain is data, we kept saying; point it at any catalogue with real depth and the architecture adapts. One deployment is not proof of that, and we knew it.</p><p>That claim was free to make and expensive to verify. A single deployment proves nothing about portability. The only honest test was to stand the whole thing up on a completely different store, one whose domain shared almost nothing with the first, and see what broke. So we picked a target that was as far from outdoor gear as we could find while still being a catalogue with genuine domain depth: Vertical B, a specialist hobby retailer, the kind of store where choosing well takes real knowledge the shopper does not arrive with.</p><p>We did it as a full fork of the original repository, not a branch. That choice mattered more than it looks, and we will come back to why. The point for now is that the test was deliberately adversarial. If the architecture was going to leak domain assumptions, a clean fork onto an unrelated store was the place it would show.</p><h3>What we moved, and what we did not</h3><p>The surprise was how little of the engine we touched.</p><p>What changed was the domain substrate, and only the domain substrate. The product catalogue was new. The knowledge base behind the advisor was new. The needs-assessment question sequence was rewritten. The persona and the agent system prompts were rewritten for the new voice. The currency changed. Even the six proactive intervention messages, the nudges the assistant offers unprompted, were rewritten for the new store. The swap reached well past the catalogue and into every place the old domain had left a fingerprint.</p><p>The assessment questions are the clearest example of why this could not be a shallow find-and-replace. In the outdoor store, the advisor asked about climate and trip duration, because those are the facts that decide which jacket is right. In a specialist hobby store those questions are meaningless. So they were replaced with domain-specific ones that map to how a shopper in the new store actually narrows a decision. The mechanism that runs the assessment did not change. The questions it asks did, completely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WIgPsZn_1FPsKdHaA0pYkw.png" /><figcaption><em>Everything above the protocol line is data and prompts. Everything below it is the engine, and it did not move.</em></figcaption></figure><h3>The protocol line held</h3><p>Below the line where the domain lives, the engine stayed put.</p><p>The ISA protocol and its tool definitions were carried over unchanged. The shopping toolset was identical, line for line. The multi-agent runner, the coordinator-to-specialist wiring, and the tool and action pipeline were the same code structurally; the only differences in that layer were non-domain wiring, not behaviour, not contracts, and not a single dispatch rule. The hybrid search service was unchanged. The tool and action pipeline is the path a tool result takes from the backend out to the frontend and back. These were the same files with the same class names in both repositories.</p><p>The only thing that changed inside the agents was prompt content, and it changed for voice and domain, never for behaviour. The advisor was still an advisor; it just spoke in the new store’s register and reasoned about the new store’s products. The shopping agent still searched and edited a cart. The coordinator still routed. We did not rewrite a single dispatch rule or retype a single contract. The voice moved; the machine underneath it sat still.</p><p>This is the moment that turned the vertical-agnostic claim from a slide into a fact. We had asserted the engine was domain-independent. The diff showed it: the parts that did not move were exactly the parts we had hoped were reusable, and the parts that moved were exactly the parts we had always called data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3gkGOOAhYXQGfOFEm8zmhw.png" /><figcaption><em>Two stores, one engine. The domain is a bundle that plugs in; the engine is the part we keep.</em></figcaption></figure><h3>Disabled, not deleted</h3><p>The discipline that kept the swap safe was a rule we set before writing any code: switch the old domain off, do not rip it out.</p><p>It would have been tempting to delete the outdoor store’s domain-specific machinery outright. We did the opposite, deliberately, in three places. The original vertical had a domain-specific toolset; instead of deleting it, we stubbed it to return a clear “not available” payload. The reason was precise: the shared executor that runs every tool was code we did not want to touch, because editing it risked drift from the original fork and from the other repository we keep in sync. A stub that answers cleanly leaves the executor untouched. A deletion forces you into it.</p><p>The original vertical’s HTTP routes got the same treatment. They were left in place but now return 410 Gone with a clear message, so anything still pointing at them gets an honest answer instead of a mysterious 404 or a half-working endpoint. And a domain-utility agent that had no equivalent in the new store was left unwired rather than removed, so it sits in the tree, disconnected, doing nothing, breaking nothing.</p><p>The measurable result of switching the domain tools off is a clean number: the default tool count dropped from 33 to 18. Almost half the tools the agents could reach were domain-specific to the outdoor store, and turning them off rather than deleting them is what let us make that change without surgery on shared code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c4eisWUaE7J-FE-3vBQN-A.png" /></figure><h3>Why a fork, not a branch</h3><p>We forked the repository rather than branching it, and the reasons are worth stating because the instinct usually runs the other way.</p><p>A branch keeps the two stores in one history and invites you to share fixes between them automatically. That is exactly what we did not want. We wanted clean divergence: Vertical B as its own repository, with its own demo and its own deploy, free to drift in domain content without constant merge negotiation against the original. A fork also gives each store a legible, linear story. Anyone reading the Vertical B history sees one narrative, the swap and everything after it, without the original store’s unrelated commits threaded through.</p><p>The fork made the swap a concentrated event rather than a slow trickle. The domain-swap commits landed across 2026–04–20 to 2026–04–21, a short, concentrated push on top of a shared codebase, not a rewrite. That window is itself a result worth noting. Moving an entire AI concierge to an unrelated retail vertical in that short a window was only possible because the engine did not have to move with it. The fork concentrated the swap; the reason it stayed small is in the count. Eighteen tools had to move, not thirty-three, and the engine did not move at all.</p><h3>The debt we left on purpose</h3><p>Some of the old domain stayed visible in the code, and we left it there on purpose.</p><p>The previous persona’s React component is still named for the old persona. So is a state hook, a Redux slice, a directory, and the legacy CSS class prefix that runs through the styling. None of it surfaces to the shopper; it is all internal naming. We could have done a rename pass and made the codebase read as if Vertical B had always been the only store. We chose not to, and the choice is recorded rather than hidden. An authoritative fork-state document lists exactly what was changed and what was deliberately left alone, including this cosmetic debt, so nobody reading the code later mistakes a leftover name for an active dependency on the old domain.</p><p>The same document lists what we deliberately did not do: the rename pass we just described, a full sweep of the legacy documentation, and persistent session storage. These are written down as known deferred work, not as oversights. It lists each change with whether it was applied or deliberately deferred, so a future reader can tell active code from a harmless leftover. The distinction matters. A leftover name in shared code looks, months later, like it might be doing something. The fork-state document makes the answer take seconds instead of an hour.</p><h3>The lesson</h3><p>Here it is, stated plainly: vertical-agnostic is a property you prove by moving, not by claiming. We had said the engine was domain-independent for months. We only knew it once we had carried it to a store that shared none of the first one’s assumptions and watched the protocol line hold while everything above it changed. The proof was in what we did not have to touch.</p><p>What would we do differently? We would do the second deployment earlier. A reference architecture that has only ever run one place is a hypothesis, and we carried that hypothesis longer than we should have before testing it. We would also treat the disabled-not-deleted discipline and the fork-state document as standard from the first fork, not lessons we happened to apply well this time. The thing that made the swap fast was not cleverness during the swap. It was the boundary we had drawn earlier, between the domain that plugs in and the engine that stays, and a fork-state document honest enough to tell us which side of that line every leftover sat on.</p><p>The decision this part rests on, and what it cost:</p><blockquote><strong><em>The decision.</em></strong><em> Fork rather than branch, swap only the domain bundle, and disable the old domain instead of deleting it.</em></blockquote><blockquote><strong><em>Why.</em></strong><em> A clean fork was the honest test of the vertical-agnostic claim, and disabling rather than deleting kept the shared engine untouched.</em></blockquote><blockquote><strong><em>What it cost.</em></strong><em> Two repositories to keep in sync, and deliberate, documented cosmetic debt from the old domain’s leftover names.</em></blockquote><p>The engine moved stores and barely noticed.</p><h3>The architecture after part 2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vcoHtzRH3bGwmR2yndAnxg.png" /><figcaption><em>Part 2 changed only the domain bundle. The engine below the protocol line did not move, which is the whole point.</em></figcaption></figure><p><strong><em>Next in the series: the search engine underneath.</em></strong><em> The advisor is only as good as what it can find. We get into why vector search kept missing exact model numbers, how we fused semantic and keyword matching into a single query, and how that search moved to a managed cluster.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a458285fbb21" width="1" height="1" alt=""><hr><p><a href="https://medium.com/techunfiltered-ayata/one-engine-a-different-store-a458285fbb21">One Engine, a Different Store !</a> was originally published in <a href="https://medium.com/techunfiltered-ayata">TechUnfiltered@Ayata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building an enterprise AI shopping concierge: The Series]]></title>
            <link>https://medium.com/techunfiltered-ayata/building-an-enterprise-ai-shopping-concierge-the-series-7e08bf8ddb44?source=rss-a0af501420db------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e08bf8ddb44</guid>
            <category><![CDATA[ayatacommerce]]></category>
            <category><![CDATA[agentic-ai-architecture]]></category>
            <category><![CDATA[agentic-commerce]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[multi-agent-systems]]></category>
            <dc:creator><![CDATA[Stanley Joseph]]></dc:creator>
            <pubDate>Fri, 05 Jun 2026 16:31:18 GMT</pubDate>
            <atom:updated>2026-06-22T10:59:49.341Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nBBCqS2Cc-JRLvvAh_pZHQ.png" /></figure><p>This series documents the engineering behind an AI shopping concierge, from the first working prototype through four distinct rebuilds. Each article follows one decision: what we changed, why, and what it cost, with the code shown rather than summarised. Start at <a href="https://medium.com/techunfiltered-ayata/the-advisor-not-the-search-box-7b4fdf5fdb3b">part 1</a>, or jump to whichever decision you need.</p><h3>The system we are building toward</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4e4nMcvfECmdgAr7_DLshQ.png" /><figcaption><em>The reference architecture in its final, AWS-reference form. Every article highlights the part it changed, and the map fills in as the series proceeds.</em></figcaption></figure><h3>The journey: one product, four rebuilds</h3><ol><li>The original. A single-domain concierge: the advisor, the multi-agent runtime, the typed contract.</li><li>The fork. The same engine moved to a completely different store, to prove the architecture was vertical-agnostic.</li><li>The multi-cloud baseline. The provider and storage abstractions that let one codebase run on more than one cloud.</li><li>The AWS reference. The single-cloud rebuild, the runtime swap, and the platform controls that make it safe to ship.</li></ol><h3>The articles</h3><p><strong>Live</strong>:</p><ul><li><strong>Part 1: The advisor, not the search box.</strong> Why the hard problem in conversational commerce is the expertise gap, and how a multi-agent advisor that assesses before it answers solves it. <a href="https://medium.com/techunfiltered-ayata/the-advisor-not-the-search-box-7b4fdf5fdb3b">Read part 1</a></li><li><strong>Part 2: One engine, a different store.</strong> Proving the engine was vertical-agnostic by forking it onto an unrelated store and changing nothing below the protocol line. Read <a href="https://medium.com/techunfiltered-ayata/one-engine-a-different-store-a458285fbb21">part 2</a></li><li><strong>Part 3: Why semantic search kept burying the exact match.</strong> Vector search alone hid the product the shopper named. Fusing semantic and keyword search, the score-scale trap that hid underneath, and why relevance is a business surface. <a href="https://medium.com/techunfiltered-ayata/why-semantic-search-kept-burying-the-exact-match-d811a605cc0a">Read part 3</a></li><li><strong>Part 4: We abstracted the LLM provider, then deliberately un-abstracted it.</strong> Why a clean multi-vendor interface was the right bet for the multi-cloud baseline, why collapsing it was the right bet for the single-cloud reference, and why un-abstracting relocated the seam rather than deleting it. <a href="https://medium.com/techunfiltered-ayata/we-abstracted-the-llm-provider-then-deliberately-un-abstracted-it-d4ff1ede176c">Read part 4</a></li></ul><p><strong>Planned</strong>:</p><ul><li>Part 5: Skipping the validation spike.</li><li>Part 6: Putting a meter on the agent.</li><li>Part 7: The bug that hid in a background thread.</li><li>Part 8: Demos that run with no cloud credentials.</li><li>Part 9: The data the model never saw.</li><li>Part 10: Proving the guardrails actually hold.</li><li>Part 11: What four iterations taught us about building enterprise agents.</li></ul><p>Links are filled in as each part is published.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e08bf8ddb44" width="1" height="1" alt=""><hr><p><a href="https://medium.com/techunfiltered-ayata/building-an-enterprise-ai-shopping-concierge-the-series-7e08bf8ddb44">Building an enterprise AI shopping concierge: The Series</a> was originally published in <a href="https://medium.com/techunfiltered-ayata">TechUnfiltered@Ayata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The advisor, not the search box !!]]></title>
            <link>https://medium.com/techunfiltered-ayata/the-advisor-not-the-search-box-7b4fdf5fdb3b?source=rss-a0af501420db------2</link>
            <guid isPermaLink="false">https://medium.com/p/7b4fdf5fdb3b</guid>
            <category><![CDATA[ayatacommerce]]></category>
            <category><![CDATA[ai-concierge]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <category><![CDATA[agentic-commerce]]></category>
            <dc:creator><![CDATA[Stanley Joseph]]></dc:creator>
            <pubDate>Fri, 05 Jun 2026 14:01:57 GMT</pubDate>
            <atom:updated>2026-06-05T14:01:57.373Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fWYqBjJiuDwKJyx7m8QhKw.png" /></figure><p><em>This is part 1 of a series on building an enterprise AI shopping concierge. We trace one product through four ground-up rebuilds and document what each rebuild broke and what it fixed, with the engineering shown rather than asserted.</em></p><p><em>The AI Concierge is a multi-agent assistant for online retail. Instead of handing the shopper a list of results and walking away, it works out what the shopper actually needs, then recommends and explains. Specialist agents cover advice, search, cart, and support behind a typed contract, alongside the platform controls that make an agent safe to run in production: guardrails, cost limits, and an audit trail.</em></p><p><em>In this part: why the concierge had to become an advisor before it could become anything else.</em></p><p>A shopper types four words into the search box of an outdoor-equipment retailer (Vertical A in our internal shorthand). The query is something like “warm jacket for hiking” (illustrative, but close to the real traffic). The catalogue does its job. It returns a hundred results, ranked, filtered, faceted. Every one of them is a warm jacket. Every one of them could be the right answer.</p><p>The shopper is still stuck.</p><p>This is the moment that started the whole project, and it took us longer than we would like to admit to name it correctly. We kept treating it as a retrieval problem. Better ranking, better filters, better synonyms. But the shopper did not have a retrieval problem. They had an expertise problem. They did not know which of the hundred jackets was right for them, because choosing well required knowing things they did not know to ask: what temperature range they would face, whether they needed a hard shell or insulation, what “breathability” trades against on a steep climb. The search box could find anything. It could not advise. That gap, between finding and advising, is where the assistant had to live.</p><p>Retrieval got good enough to expose the real problem underneath it: a shopper who knows the category but not which item in it is right for them. The advisor is our answer to that second problem. We suspect it generalizes to any category with real domain depth, where choosing well needs knowledge the shopper does not have yet, but we make that claim from this one project, not from first principles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iSZNuVqTygKd1tWYUKaPIg.png" /><figcaption><em>Same query, two approaches. Retrieval hands back a list; the advisor asks first, then explains.</em></figcaption></figure><h3>What we tried first</h3><p>The starting point was Google Gemini paired with the Google ADK agent framework.</p><p>The obvious first build was a single assistant bolted onto the catalogue. One model, one prompt, a search tool and a cart tool. The shopper asks a question, the assistant searches, the assistant answers. This single-model approach came first, and the multi-agent split arrived later in the project. For a large class of requests this worked fine. “Show me red jackets under two hundred” is a retrieval request wearing a sentence, and a single assistant handles it cleanly.</p><p>It broke down the moment the request needed domain reasoning. Ask the single assistant “what should I bring for a three-day trek” and it would dutifully run a search and hand back a wall of products, because searching was the only move it really had. It had no notion of assessing the person before recommending the gear. It would happily recommend a summer-weight item to someone describing a winter route, because nothing in the loop forced it to find out which one they were.</p><p>We reached for the usual fix and made the prompt do more. That did not add expertise. As the single prompt grew, it became load-bearing in too many directions at once: routing, searching, assessing, recommending, and order support all leaned on the same instructions, and each new direction added surface area for the model to drift. A longer prompt made every other behaviour slightly worse. The model’s attention was split across all of it on every single turn. The monolith was not under-engineered. It was structurally asked to be too many things, and no amount of prompt could fix that.</p><h3>The shift: assess before you answer</h3><p>Stop answering the question as asked. Assess first.</p><p>We gave the advisor two backend tools. The first, start_needs_assessment, runs a guided, sequential discovery before any recommendation is made. It walks the shopper through use case, experience level, budget, and more, one step at a time, and it blocks any recommendation until those questions are answered. It is a fixed order, not a free conversation. It does not recommend anything yet. It listens.</p><p>The second, get_expert_recommendation, is where the accumulated context pays off. It returns must-haves, novice warnings, and pro tips, and then it auto-fetches the products that match what it just recommended. The shopper does not get a hundred jackets. They get a short shortlist that fits the answers they gave, plus the reasoning for why those items and not the rest. Illustratively, for the winter-route shopper the advisor might lead with an insulated hard shell, flag that a single mid-layer will not hold heat below a certain point, and note that taped seams matter more than the marketing copy suggests. The contrast with the hundred-result wall is the point: the reasoning is what the search box could never produce.</p><p>Underneath that recommendation, retrieval did not go away. It just stopped being the headline. When the advisor auto-fetches products, it runs a hybrid search that blends semantic and keyword signals at a fixed weighting of 0.6 semantic and 0.4 keyword. The final relevance score is semantic times 0.6 plus keyword times 0.4, with a 1.2x boost for items that show up in both result sets. Good retrieval still matters. It is the tool the expertise reaches for, rather than the product itself.</p><p>The important architectural decision is that both of these are backend-internal tools. They are never returned to the frontend for execution. The assessment and the recommendation are reasoning steps that happen inside the agent before anything reaches the user’s screen. This distinction (internal reasoning tools versus client-facing actions) turned out to be load-bearing, and we will come back to it.</p><h3>The split: one coordinator, four specialists</h3><p>We split the single assistant into a multi-agent system: a root coordinator plus four specialist agents: shopping, advisor, support, and a domain-utility agent that we will set aside here. The coordinator’s only job is to read the shopper’s message and route it to the specialist that owns the relevant tools. We introduced this architecture on 2026–02–01.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*utNLwYn7FQtpL4COQjcuyQ.png" /><figcaption><em>The coordinator routes each turn to the specialist that owns the relevant tools.</em></figcaption></figure><p>The routing used Google ADK’s native sub_agents mechanism, which auto-creates transfer tools between the coordinator and its specialists. We did not write a dispatch layer. The routing rules lived in the coordinator&#39;s instruction prompt, not in hand-written dispatch code. That had two payoffs we did not fully anticipate. The first was tokens: each specialist carries only its own tools and its own instructions, so any given turn loads a fraction of the context the monolith carried. The second was reasoning clarity. The advisor came out patient and consultative, because it only ever assesses and recommends. The shopping agent came out fast and transactional, because it only ever searches and edits a cart. Each specialist loads only its own tools, so each turn carries less to reason over, and neither has to compromise on a shared personality.</p><p>Multi-agent architectures call the model more, not less. A single “what should I buy” turn can touch the coordinator, the advisor, the assessment step, and the recommendation step, several model calls before the shopper sees an answer. At that depth the cost is no longer a rounding error, and cost, latency, and orchestration discipline stop being ops concerns you bolt on at the end and become first-order design decisions. We learned to treat a wasted model call the way we treat a wasted database query.</p><h3>The contract that kept frontend and backend honest.</h3><p>A multi-agent backend that can take actions in the world needs a hard boundary with the frontend, or it turns into mud. Ours is the ISA protocol: a typed Pydantic contract with ISARequest, ISAResponse, ISAAction, ISAContext, and an ActionName enum. Every message in and every message out is a known shape. There is no free-text channel where the backend asks the frontend to please do a thing.</p><p>The part that earns its keep is the split between two kinds of action. Client actions are executed on the frontend (add to cart, navigate, run a product search against the live store). Internal actions are executed on the backend (the assessment and recommendation tools from earlier). The split is not a convention we hoped people would follow. It is enforced by explicit CLIENT_TOOLS and INTERNAL_TOOLS sets, and any client action is marked with a ClientAction wrapper carrying an __isa_client_action__ flag. If a tool result is meant for the browser, it says so in its own type. If it is internal reasoning, the frontend never sees it. Without that boundary the failure is mundane and constant: the backend tries to execute a navigate or add-to-cart that only the browser can perform, or it leaks the raw output of an internal assessment tool back to the client as if it were a thing to render.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/784/1*dsaF_JwQ7RhLZs7JTKe57w.png" /><figcaption><em>One round trip: the backend decides, the frontend executes client actions, and results flow back for continuation.</em></figcaption></figure><h3>The lesson</h3><p>Here it is, stated plainly: in guided commerce, domain expertise beats retrieval. The shopper who got a hundred results was not under-served by the search engine. They were under-served by the absence of someone who knew the domain well enough to ask the right questions first. Once we modelled that someone, as an advisor that assesses before it answers, routed to by a coordinator that keeps each specialist focused, behind a typed contract that keeps actions honest, the product stopped feeling like a search box with a chat skin and started feeling like help.</p><p>What would we do differently? We would name the problem as expertise, not retrieval, on day one, and build the assessment-first advisor before the single-assistant version, instead of spending a month learning that a bigger prompt does not become more expert. We would also write these articles while the code is still changing, not after we have decided it is finished. The single-assistant monolith was deliberate debt, documented and paid down on purpose, and treating debt as a tool rather than a failure is what let us move quickly without lying to ourselves about what we had built.</p><p>A working advisor demos well. What a demo hides is everything that makes the agent safe to hand to a real retailer: guardrails so it cannot promise a refund policy that does not exist, per-session cost limits so one shopper cannot run up an unbounded model bill, an audit record for every model and tool call so you can replay what happened when something goes wrong, and hard separation between tenants so one retailer’s data never reaches another’s session. None of that shows up in a demo, and all of it had to exist before any retailer we showed this to would put it in front of customers. The rest of this season is largely about building those pieces.</p><p>The shopper never wanted a better list. They wanted to be asked the right question. Build that first.</p><p><strong><em>Next in the series: one engine, a different store.</em></strong><em> We took this same multi-agent engine and moved it to an unrelated retail domain in about four weeks, changing nothing below the protocol layer. We get into what carried over untouched, what we left as deliberate documented debt, and why we forked the codebase instead of branching it.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7b4fdf5fdb3b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/techunfiltered-ayata/the-advisor-not-the-search-box-7b4fdf5fdb3b">The advisor, not the search box !!</a> was originally published in <a href="https://medium.com/techunfiltered-ayata">TechUnfiltered@Ayata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Welcome to TechUnfiltered@Ayata: A New Era of Transparency in Tech]]></title>
            <link>https://medium.com/techunfiltered-ayata/welcome-to-techunfiltered-ayata-a-new-era-of-transparency-in-tech-1bc44a2a5885?source=rss-a0af501420db------2</link>
            <guid isPermaLink="false">https://medium.com/p/1bc44a2a5885</guid>
            <category><![CDATA[composable-commerce]]></category>
            <category><![CDATA[composable-architecture]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[unfiltered]]></category>
            <category><![CDATA[enterprise-technology]]></category>
            <dc:creator><![CDATA[Stanley Joseph]]></dc:creator>
            <pubDate>Thu, 19 Sep 2024 13:04:02 GMT</pubDate>
            <atom:updated>2024-09-19T13:04:02.922Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RY2cp7ufE2e7JozRnkAnPA.png" /></figure><p>The world of technology is evolving at an unprecedented pace, and with it, the stories we tell about our work are changing too. Today, we are thrilled to launch <strong>TechUnfiltered@Ayata</strong>, AyataCommerce’s new publication on Medium. Our aim is simple: to bring you the unvarnished truth about what it’s like working in the trenches of the <strong>Composable Enterprise</strong> space as a <strong>Systems Integrator</strong> and <strong>Digital Agency</strong>.</p><p>If you’ve been scrolling through LinkedIn lately, you’ve probably noticed a trend — people talk about their work through rose-tinted glasses, presenting only the polished, successful outcomes. We’re here to change that narrative. <strong>TechUnfiltered@Ayata</strong> is where you’ll find our authentic perspective on the day-to-day challenges, mistakes, lessons learned, and, yes, the victories too. We’ll show you what happens behind the scenes, the real processes that make modern tech projects tick, especially in the areas of <strong>Composable Architecture</strong>, <strong>Agile Methodologies</strong>, and <strong>DevOps</strong>.</p><h3>Why Read <strong>TechUnfiltered@Ayata</strong>?</h3><p>At AyataCommerce, we believe there’s immense value in honesty and transparency. We’ve seen the power of learning from the experiences — good and bad — of those who walk similar paths. Through <strong>TechUnfiltered@Ayata</strong>, we’ll be sharing insights and perspectives that many in the tech world shy away from:</p><ul><li><strong>Authentic Stories from the Field</strong>: Every article is written by our engineers and thought leaders who are in the thick of things, solving real-world problems, and constantly adapting to the fast-evolving world of tech.</li><li><strong>Learning from Mistakes</strong>: In an industry obsessed with success stories, we’re here to tell you about the other side too. Our engineers will candidly discuss mistakes we’ve made, and more importantly, how we learned from them.</li><li><strong>Actionable Best Practices</strong>: Whether you’re into <strong>Composable Enterprise</strong>, integrations, or <strong>Agile Development</strong>, you’ll find tips and best practices grounded in real-world experience.</li><li><strong>Continuous Improvement &amp; DevOps Insights</strong>: As enthusiasts of <strong>Agile, DevOps</strong>, and <strong>continuous improvement</strong>, we’ll share our journey in these areas, including how we experiment, iterate, and evolve our processes for better outcomes.</li></ul><h3>Why Subscribe to Our Newsletter?</h3><p>Alongside the blog, we’re excited to offer a <strong>TechUnfiltered Newsletter</strong>, designed to bring these stories directly to your inbox. Here’s what you can expect when you subscribe:</p><ol><li><strong>Exclusive Content</strong>: Get deeper insights into the topics we discuss on the blog, with bonus materials, behind-the-scenes stories, and detailed how-to-s.</li><li><strong>The Art of Possibility in Tech</strong>: We love exploring the “art of the possible.” From case studies to innovative solutions, our newsletter will showcase real-world examples of how technology is transforming businesses and opening up new avenues of possibility.</li><li><strong>Curated Content</strong>: Stay up-to-date with the latest trends, tools, and techniques in <strong>Composable Commerce</strong>, <strong>DevOps</strong>, <strong>Agile</strong>, and more. We’ll curate valuable content from across the web to keep you informed without information overload.</li><li><strong>Interactive Q&amp;A</strong>: We want to engage with you! Our newsletter subscribers will get access to exclusive Q&amp;A sessions with our tech experts, where you can ask your burning questions.</li></ol><p>If you’re passionate about tech, if you’ve ever been frustrated by the overly polished stories you read online, or if you just want to learn from authentic, real-world experiences in systems integration and digital solutions, <strong>TechUnfiltered@Ayata</strong> is for you. We’re excited to share our journey with you — complete with all the bumps, twists, and turns along the way.</p><p>The <strong>TechUnfiltered</strong> movement starts here. Join us as we reshape the way we talk about technology.</p><p>Stay tuned for our next post, where we dive into one of our favourite topics: <strong>Integrations Patterns and its relevance in Composabale Enterprise</strong> — what it is, why it matters, and how we’re implementing it to revolutionise digital experiences.</p><p><em>Subscribe to our newsletter</em> and start your unfiltered journey with us today.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bc44a2a5885" width="1" height="1" alt=""><hr><p><a href="https://medium.com/techunfiltered-ayata/welcome-to-techunfiltered-ayata-a-new-era-of-transparency-in-tech-1bc44a2a5885">Welcome to TechUnfiltered@Ayata: A New Era of Transparency in Tech</a> was originally published in <a href="https://medium.com/techunfiltered-ayata">TechUnfiltered@Ayata</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>