<?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[Ewake.ai - Medium]]></title>
        <description><![CDATA[First Collaborative AI Production Teammate - Medium]]></description>
        <link>https://medium.com/ewake-ai?source=rss----8e46b9c07775---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Ewake.ai - Medium</title>
            <link>https://medium.com/ewake-ai?source=rss----8e46b9c07775---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:54:02 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/ewake-ai" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Don’t React. Respond. Why We Rebuilt Our SDLC for Focus]]></title>
            <link>https://medium.com/ewake-ai/dont-react-respond-why-we-rebuilt-our-sdlc-for-focus-3777ef8ecfbf?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/3777ef8ecfbf</guid>
            <category><![CDATA[engineering-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[shape-up]]></category>
            <category><![CDATA[sdlc]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Cian Duffy]]></dc:creator>
            <pubDate>Fri, 29 May 2026 12:11:36 GMT</pubDate>
            <atom:updated>2026-05-29T12:11:35.138Z</atom:updated>
            <content:encoded><![CDATA[<h4>Startup culture is built on multitasking, but human brains aren’t. Here is how we redesigned the Ewake SDLC to ruthlessly protect our focus.</h4><figure><img alt="A minimalist engineering schematic of a conveyor belt. On the left, a mechanical robotic boot kicks a chaotic jumble of distractions — including Slack icons, email envelopes, and a box labeled “HEY QUICK ONE!” — off the belt. Past the boot, the conveyor belt continues smoothly, carrying only clean, evenly spaced, glowing green geometric cubes representing focused, uninterrupted work." src="https://cdn-images-1.medium.com/max/1024/1*jD80DaJj1bpL3925gV3YVw.png" /></figure><p>I’m a multitasking Luddite. I don’t like it, never have. It’s an occupational hazard in our line of work, and codegen has only made it faster (worse). My theory that constant multitasking is a bad way to live has only got stronger.</p><p>The proof, tragically, came in the form of an Instagram reel. In my defence, it was an unusually well-cited Instagram reel. I interrupted my doomscroll to follow up on their research, went down a rabbit hole, and emerged with <em>evidence</em>.</p><p>It turns out the consensus in neuroscience is pretty unambiguous: Multitasking is a myth. Human brains literally don’t have the architecture for it. What we <em>think</em> is multitasking is just rapid task-switching.</p><p>Researchers have been sounding the alarm about this for a while. <a href="https://dl.acm.org/doi/10.1145/1357054.1357072">Mark et al. (2008)</a> proved that while thrashing between tasks might make us feel faster in the short term, it inevitably leads to burnout. Even when people are completely free to organise their own schedules, the ones who choose to multitask perform significantly worse than those who force themselves to work sequentially (<a href="https://www.cambridge.org/core/journals/experimental-economics/article/multitasking/0D8CADEA4C6F6ACDBB1E51615B5D67DA">Buser &amp; Peter, 2012</a>).</p><p>This rapid task switching isn’t free. It’s not even cheap. Every time you shift focus, your brain has to drop its current cognitive framework and load a new one. <a href="https://journals.lww.com/annals-of-medicine-and-surgery/fulltext/2024/11000/digital_multitasking_and_hyperactivity__unveiling.5.aspx">Hasan (2024)</a> found that the mental load required to constantly reorient yourself can cost <strong>up to 40%</strong> of your productive time. Worse, dividing your resources like this overloads your working memory, which directly leads to mental fatigue and poor decision-making.</p><p>So if it makes us slower, worse at our jobs, and actively drains our mental health, why do we keep doing it?</p><p>Because of the dopamine illusion. In his book <a href="https://www.daniellevitin.com/the-organized-mind"><em>The Organized Mind</em></a>, neuroscientist Daniel J. Levitin explains that our brains are uniquely wired to reward novelty. Every time you context-switch, your brain gets a hit of dopamine for uncovering new information. You feel productive because you are actively “doing things”. In reality, you’re just rewarding your brain for being distracted.</p><p><strong>tl;dr</strong>: Cian read 3 (three) research papers and a synopsis of a book, all of which supported his opinion that constant multitasking is slow and bad for you.</p><p>The 40% number was a bit of a shock. The rest was validation.</p><p>When I started looking at our engineering process with the dopamine illusion in mind, I saw it everywhere. Our “agile” startup culture was actually just an excuse for team-wide, institutional multitasking.</p><h3>We were thrashing</h3><p>When we started, we were doing the Startup™️ thing. The instinct was that the shortest distance from an idea to a signal was the way to go. We planned once a week. We interrupted nearly every cycle with customer asks. We started on things and kept going with them until something more important came up, which was often.</p><p>I remember one week back in September clearly. We were head-down on “real” work all week, with no time to plan, and walked into planning on Friday with half-baked ideas. The meeting was the first time we’d actually interrogated those ideas, and within twenty minutes it was clear they weren’t ready. So we had to do planning again on Monday. We were spinning our wheels.</p><p>We’ve <a href="https://www.ewake.ai/blog/the-cost-of-cheap-code">written before</a> about the PR-queue side of this — what happens when your review cadence can’t keep up with the rate of new code. That was the tactical layer. This is the strategic layer, and it starts before any code gets written. Individually, we felt fast. Across a month, we were getting less done. The cost was just off the books.</p><h3>Shape Up Lite</h3><p>We went shopping for methodologies, and landed on Shape Up for how it treats scope. Rather than estimating how long a piece of work will take (weird and difficult these days with codegen tooling), we define an appetite up front. We say “as a team, we are willing to invest this much time in this project”. If we hit the appetite limit, we cut scope, or we increase the appetite. The crucial thing is that we make a decision about what to do.</p><p>We design the scope up front using a document called a one-pager. This document explicitly defines the appetite, what’s in scope, (crucially) what’s out of scope, and the risk factors that could result in the project missing its appetite.</p><p>Each project started with a one-pager. We got better at defining scope in advance. But we weren’t ready to commit to the full-on Shape Up active-cycle-plus-cooldown model yet, so we kept doing normal sprint planning every two weeks alongside it.</p><p>The other change we made was around our approach to technical design. We were trying to parallelise, and ended up siloing. We kept landing on design discussions in PRs, debating whether the underlying approach was correct after the code had already been written. We started emphasising design on paper before touching code.</p><h3>Shift the work left</h3><p>The principle is simple: Time spent on scope saves more time on design, and time spent on design saves more time on code review and implementation.</p><p>The efficiency gains were immediate. Design debates that would have taken a day on a PR were handled in an hour at the design review stage. Missed requirements were caught at the scope review instead of having to be retrofitted. Bad features were cancelled before they got off the ground rather than having their PRs blocked.</p><p>Codegen made this more important. <a href="https://en.wiktionary.org/wiki/fad%C3%B3_fad%C3%B3">Fadó fadó</a>, when an engineer used to take three days to implement a feature, we had time to make directional adjustments to the design as we went. Claude Code is fire and forget. If you point it in the wrong direction, it will happily implement a terrible design for you in no time. Because generating code is practically free now, human architectural thought has become the most valuable commodity in our SDLC. Knowing exactly what we’re building before getting into it isn’t optional anymore. It’s the whole job.</p><p>For a few weeks, this felt like a revelation. We had fixed the scoping problem, the PR queue was breathing again, and engineers felt like they had real agency over their technical choices.</p><p>So we were in business. Problem solved, right?</p><figure><img alt="J.K. Simmons in Whiplash closes his fist in tense, barely controlled anger to interrupt an imperfect performance." src="https://cdn-images-1.medium.com/max/480/1*P2YQNdUp5DrwJa9WM21C8A.gif" /></figure><h3>Not quite.</h3><p>We were still squeezing in one-pagers between “real” work. We rarely had the time to prep them properly, so we often ended up throwing a one-week appetite at a sparse ticket just to keep things moving — which forced us to figure out scope in real time instead of actually shaping it.</p><p>Because we were writing one-pagers sequentially, engineers would finish their current project and find no shaped work waiting. They’d hit the brakes, draft a one-pager, wait for async reviews, and pick up small “quick wins” while they waited. Momentum on the things that actually mattered kept stalling.</p><p>Finally, we still didn’t have a great mechanism for changing priorities mid-cycle. Work would come in and we would either jump on it, or stick it in Linear and hope that we’d get to it.</p><p>By half-doing Shape Up, we had created a spork — still better than a fork for eating soup, but we wanted more.</p><h3>Going all in</h3><p>Our fix was to commit to Shape Up properly. An active cycle for aggressive development, followed by a cooldown period for maintenance, planning, and prep. Basecamp’s default cadence here is six weeks on, two weeks off. The ratio seemed to work for them, but for an 8-person startup, 6 weeks was too long to commit to. We halved it, going for a three-week active cycle followed by a cooldown week.</p><p>The cooldown week isn’t a week off. It’s for prep. Engineers act as Shapers, iterating with founders async on the one-pagers for the next active cycle. Appetites get debated and locked. By the end of cooldown, we have a slate of shaped bets (projects) ready to go.</p><p>The planning meeting for each active cycle has become a short <em>Betting Table</em>. We look at the shaped one-pagers and decide which bets to fund for the next three weeks. Once we get out of that meeting, the team is unblocked for a month. Nobody has to draft a one-pager or argue about scope during the active cycle. We just build.</p><h3>The zero-sum game</h3><p>At this point you’re probably thinking that three weeks is a long time for a startup to lock into a plan. You’d be right. The only way to make it work is to treat the cycle as a zero-sum game.</p><p>If something super-important comes in mid-cycle, we should do it. But we have to understand that doing this means that something else drops out of the cycle. This shifts the conversation from “Can we do this?” (to which the answer is almost always “yes, technically”), to “should we do this instead of that?”.</p><p>This is the part where the cognitive science comes back into play — briefly. Interruptions feel free to the interruptor. The team bears the cost. We call this the <strong>Context Tax</strong>, and the cycle makes it visible. We don’t avoid paying it — sometimes the new thing genuinely is more important. We just make sure we’re paying it on purpose, and that what we’re buying is worth the price.</p><h3>How does this work in practice?</h3><ol><li><strong>New Ideas:</strong> We pull an idea from somewhere — conversations with customers, market research or the inherent creativity of our talented, humble team. The idea goes into our ideas pool in Notion, waiting to be shaped.</li><li><strong>Scoping with One-Pagers:</strong> During a cooldown week, an engineer takes the idea and works async with the founders and the team to decide on the appetite, strictly define the scope and identify risk factors. This can take anywhere from an hour to about a day. Once the scope is nailed down, it’s ready for the next step.</li><li><strong>The Betting Table:</strong> We look at all of the shaped one-pagers, and decide which ones we want to pull into the next cycle. If it doesn’t make it into this cycle, we park it and come back to it during the next cooldown week.</li><li><strong>Active Cycle</strong>: This is the easy bit — all the team has to do is put their heads down and build for three weeks. No scope debates or planning. If we run out of appetite, we either cut scope or extend the project at the expense of something later in the cycle.</li><li><strong>Handling Interruptions:</strong> Something new comes in mid-cycle. We pause for a moment. We ask ourselves “if we want to do this, what drops?” The Context Tax is named out loud, and we make an intentional decision. Either the new thing wins, and something else gets punted, or it waits for the next Betting Table.</li></ol><figure><img alt="“A wild Customer Ask Appeared!” Pokemon meme with a screenshot of Slack message saying “Hey @dev 👋 Quick one for you! Could we squeeze in a massive feature for REDACTED CUSTOMER? Thanks!” in place of a Pokemon. The message sender’s avatar is Lionel Hutz screaming. The “Customer Ask” part of the caption is in all caps and comic sans." src="https://cdn-images-1.medium.com/max/511/1*DkYyKgE77q6pBMQJJ7eZ3g.png" /></figure><h3>How it feels</h3><p>The first cooldown sounded like a light week. No feature work, no sprint goal. How busy could we be?</p><p>Pretty busy, as it turned out. Bug fixes we’d been waiting to get to, tech debt we’d been stepping around, DevEx improvements the team had wanted to make for ages. We still had three releases that week. There was a strange guilty pleasure to it. We weren’t building anything new, but we were laying the groundwork for the next cycle.</p><p>The cycle was different from the drop. We had a plan, everyone knew exactly what they were working on and where to start with it. We could just get stuck in from day one. It felt calm and composed. Not perfect, but not frantic either.</p><p>We moved faster because we stopped starting and stopping. The work was better because people could hold a whole problem in their head for longer than twenty minutes at a stretch. The decisions were better because they’d been made before we were under pressure to make them.</p><p>We weren’t less busy. We hadn’t found some secret reserve of extra hours. We just stopped paying the Context Tax by accident, and when we did pay it (because sometimes you have to), we paid it on purpose.</p><h3>What’s still hard</h3><p>In a word: Calibration.</p><p>The zero-sum rule forces us to be honest about scope, but we don’t always get it right. Some one-pagers that looked tight at the Betting Table turned out to be wider than they appeared. We’re getting better at it.</p><p>The other hard thing is judging urgency. The cycle forces a clear distinction between what <em>is</em> urgent and what <em>feels</em> urgent. That’s a judgement call, and we’ll get it wrong sometimes. Such is life.</p><p>We’re still figuring out the details, but the broad strokes seem to be working. The frantic feeling is gone and we’re getting through work fast. That’s the whole point.</p><p>The thing that changed isn’t what we ship. It’s the feeling of being mid-thought and knowing that no one is about to pull you out of it.</p><p>We still work hard, ship constantly, get curveballs. But there’s a shared plan that everyone had a hand in making. When something urgent lands, we know how to handle it. When the cycle ends, there’s something finished to point at.</p><p>And honestly, it feels gooood.</p><p><em>If this resonated, </em><a href="https://www.ewake.ai/blog/the-cost-of-cheap-code"><em>The Cost of Cheap Code</em></a><em> is the companion piece. It covers what codegen did to our PR review process, and why fixing that tactical problem made this strategic one impossible to ignore. You can find all our articles on </em><a href="https://www.ewake.ai/blog"><em>the Ewake blog</em></a><em>.</em></p><p><a href="http://www.ewake.ai/"><em>Ewake</em></a><em> is an AI SRE Agent built on a living map of your production system, designed for SREs, platform engineers, and on-call teams running production at scale.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3777ef8ecfbf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/dont-react-respond-why-we-rebuilt-our-sdlc-for-focus-3777ef8ecfbf">Don’t React. Respond. Why We Rebuilt Our SDLC for Focus</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Cost of Cheap Code]]></title>
            <link>https://medium.com/ewake-ai/the-cost-of-cheap-code-55d558f058a8?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/55d558f058a8</guid>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Cian Duffy]]></dc:creator>
            <pubDate>Thu, 30 Apr 2026 17:09:55 GMT</pubDate>
            <atom:updated>2026-05-05T08:16:55.669Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Four whale silhouettes in GitHub-style grey, arranged in a horizontal queue with the largest in the foreground. The foreground whale shows a GitHub pull request diff indicator: “+1586 / -24” in green and red, with proportion blocks beside it. The smaller whales recede into the background, suggesting a queue of pending PRs." src="https://cdn-images-1.medium.com/max/1024/1*9ecN9tMTwDD8M0vpCEO6LA.png" /></figure><p>Our first weeks with Claude Code were rough. There was a week, pretty soon after we cut over, where nothing got merged.</p><p>Not nothing-nothing. Things slipped through here and there. But the main flow of meaningful work stalled out. PRs sat. Slack filled up with variations of “Hey folks, can we get some eyes on this PR? It’s been sitting for a couple of days.” People kept opening new ones anyway, because the tool made it so easy. By the end of the week we had a queue of “whales” - massive end-to-end PRs that any one of us could produce in an afternoon, and none of us could review in less than half a day. We’re a small team at <a href="https://ewake.ai/"><strong>Ewake</strong></a>. We shouldn’t have a backed-up PR queue.</p><p>The team’s productivity was down, but, individually, we each felt like we had never been more productive. Both were true, and this contradiction is what this post is about.</p><h3>What did we do?</h3><p>The simple and clean take here is “AI tools made writing code fast, so review became the bottleneck”. This isn’t exactly a hot take any more. The statement is true, but it’s shallow. The more honest version is that the cadence of the job is different now, and we need to adapt to it.</p><p>We thought we were in good shape. We had team principles, written down months earlier. Two of them are directly relevant right now:</p><ol><li><strong>Writing is cheaper than coding.</strong> We shape ideas and solve hard architectural problems before we open the editor.</li><li><strong>Code is a liability.</strong> It only becomes an asset when it’s merged and validated. Keep branches short, optimise for integration.</li></ol><p>We agreed on these, and would quote them at each other, but we’d never really stress tested them. The slowness of human typing had been doing a lot of invisible work, camouflaging the gap between our principles and our practices. It’s hard to accidentally knock out a 1500 line PR in an afternoon when you’re the one typing it.</p><p>When producing code got cheap, that cover was gone and the gap became visible. We weren’t sloppy and we hadn’t lowered our standards. We were a team whose review urgency and prioritisation had been propped up by something that had just disappeared. Claude Code load-tested our review cadence, and DoS-ed it.</p><p>Honestly, my first reaction was a few wobbly minutes of “should we just stop using this thing?” - but that passed quickly. The tool was good. We just needed to figure out how to keep up with it.</p><h3>The Fixes</h3><p>We changed our team behaviour first. We couldn’t fix this with tooling, but we could make the behavioural changes easier to live with.</p><ol><li><strong>Reviewer-first mindset:</strong> We agreed to shape PRs for the reviewer, not the writer. The natural shape of work coming out of an AI agent is “the whole thing, in one diff,” because that’s what’s easiest to <em>produce</em>. Easiest to produce is the opposite of easiest to review.</li><li><strong>Stacked PRs:</strong> When a change does need to be large, we break it into a stack where context builds up gradually. PR 1 establishes the foundation, PR 2 reads with that context already loaded. We use <a href="https://graphite.dev/">Graphite</a> for this. Doing it natively in GitHub is miserable work. More work for the author, significantly less for the reviewer. The right tradeoff when the reviewer is the constraint.</li><li><strong>Unblocking over writing:</strong> If there are open PRs needing review, addressing them takes priority over starting new work. Not “drop tools the moment a PR opens,” but as a default ordering when choosing what to do next.</li><li><strong>The “please break this up” agreement.</strong> Anyone can ask anyone else to take a PR down and split it. The author isn’t obligated, but in practice people are good about this. As we get used to our new reviewer-first mindset, this is coming up less and less.</li><li><strong>Review SLAs.</strong> Defined for scope reviews, design reviews, and code reviews. Having a number to compare against takes the subjectivity out of “this PR has been sitting a while” and turns it into a concrete signal.</li><li>The PR digest bot. A GitHub Action that runs twice a day. It pulls open PRs from GitHub and open scope/design reviews from our Notion DBs, then lists the reviews that are:</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Ay5Lvzkeb-C9cTETxu8hQ.png" /></figure><p>It posts a digest to the relevant Slack channel, timed to natural interruption points in people’s days (first thing in the morning, just after lunch).</p><h3>PRs in the Post-Claude World</h3><p>Reviewing AI code is weird, and that’s fine. It would be weird if it wasn’t. Bugs aren’t really the issue. The code that Claude pumps out is generally pretty correct. The hard part is structural.</p><p>Claude doesn’t reuse existing patterns by default. If there’s a utility in the codebase that does roughly what’s needed, a human engineer would usually find it and use it, maybe twist it or extend it to fit the new scope. Claude will often write a perfectly parallel version, tailored to the idiosyncrasies of its current task instead. The new code isn’t bad per se, but it’s different. The resulting diff is larger because it introduces new functions instead of leaning on existing stuff. More importantly, the <em>cognitive diff</em> is wasteful.</p><p>You also lose some of the texture of the code. In every codebase I’ve shared over the years, I could usually tell which one of my colleagues had written a class or function. We all have little quirks and preferences that show up in the code we write. It’s like handwriting. You learn the patterns, build up a predictive model in your head, and it makes the code easier to navigate.</p><p>Claude doesn’t have this. It writes TypeScript like the average of every TS dev in the world, shaped by the prompt and context provided to it by the user. The lack of predictable patterns means that the code can be more difficult to understand at a glance.</p><p>So we have two new jobs as reviewers (I know they’re not really new, but the emphasis has changed):</p><ol><li>Check that we’re using what we already have</li><li>Defending the codebase against entropy</li></ol><p>The usual stuff (correctness, security, performance) is still there, but the default failure modes are different now. The dominant problems aren’t implementation bugs; they’re scope and design issues at the start of the process, and subtle coherence issues that show up over time.</p><p>Which is why we’re spending more time on scope and design reviews these days. Nailing the scope early keeps us honest and saves time in the design stage. Taking time at the design step saves us time trying to decipher what Claude has produced at the PR step. “Writing is cheaper than coding” has turned out to be even more true when you’re working with something that can write code faster than you can read it.</p><h3>How does it feel?</h3><p>There’s a weird, almost perverse tension at the centre of using codegen tools. Writing code with Claude Code is genuinely really fun. The conversational interface makes it feel like I’m delegating work to some kind of omniscient machine spirit that only cares about doing what I ask of it. It makes my little monkey brain feel suuuuper nice. It’s an infinite loop of instant gratification dopamine hits.</p><p>Reviewing someone else’s 800-line diff isn’t fun. It never has been. It’s hard, cognitively taxing work, and AI tooling didn’t change that.</p><p>What changed is the gap between coding and review. The pull toward writing code over reviewing is stronger than it was last year. It would be dishonest to pretend otherwise.</p><p>Team agreements help, but the pull hasn’t gone away yet. For now, it’s a practice that we have to work on every day.</p><h3>Where we are now</h3><p>We’re getting there. I’m not going to sit here and pretend that we alone have solved this problem. But we’re trying to face it with intellectual honesty. We’ve tightened up our dev practices, and have become more disciplined engineers. Throughput is higher than when we started using Claude. Our review queue is shrinking. PRs are getting more pleasant. They come with the context of the scope and design documents, framing and verification instructions. We’re not hitting all our review SLAs yet, but we’re getting closer every week.</p><p>The fixes I’ve described are our current best bets. If they don’t work, we’ll do something else. The team is durable. The specific solutions are disposable.</p><p>The key thing is that we’ve realised that productivity doesn’t look like creating PRs; it looks like getting useful code into users’ hands.</p><p>This is the third post in a series on how we build at <a href="https://ewake.ai/">Ewake</a>. The earlier posts cover <a href="https://medium.com/ewake-ai/anatomy-of-an-agent-spoiler-its-still-just-code-9c8d5d7b777f">what AI agents actually are</a> and <a href="https://medium.com/ewake-ai/ewake-isnt-coming-for-your-job-it-s-coming-for-your-yaml-fb563696626b">how we use them as semantic routers</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55d558f058a8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/the-cost-of-cheap-code-55d558f058a8">The Cost of Cheap Code</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ewake isn’t coming for your job; it’s coming for your YAML]]></title>
            <link>https://medium.com/ewake-ai/ewake-isnt-coming-for-your-job-it-s-coming-for-your-yaml-fb563696626b?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/fb563696626b</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[observability]]></category>
            <dc:creator><![CDATA[Cian Duffy]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 12:01:02 GMT</pubDate>
            <atom:updated>2026-03-19T14:50:09.645Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W7hDgbfNDPj7477H0Bzf4A.png" /></figure><p>In my previous life, before joining Ewake as a founding engineer, I worked at a tech giant (the one with the bridge for a logo).</p><p>Big Tech companies have a luxury that early-stage startups don’t: <strong>a unified, top-down platform</strong>. When you operate at that scale, you can mandate that every engineer uses the same logger, the same metric naming convention, and the same deployment pipeline. Entire teams exist purely to maintain that alignment.</p><p>It’s comfortable inside the walled garden.</p><p>But out here in the wild, production environments are diverse. And by <em>diverse</em>, I mean they are a mess.</p><p>The real challenge is that every company’s infrastructure evolves differently over time, and traditional software has always solved that problem with <strong>configuration</strong>.</p><p>At Ewake, we are building an AI production teammate. The goal isn’t to give engineers more buttons to click; it’s to provide a partner that lives in your stack, understands your infrastructure, and handles the “first look” when something goes wrong.</p><p>But like a human teammate, an AI still needs to be onboarded. And while most companies use familiar tools (things like Datadog, GitHub, and Slack) the way they <em>use</em> those tools varies wildly.</p><ul><li><strong>Customer A</strong> logs everything as structured JSON, cares deeply about P99 latency, and wants root-cause analysis with a code fix suggestion.</li><li><strong>Customer B</strong> dumps unstructured text logs, ignores latency entirely, and just wants a Slack message saying “Rollback” or “Don’t Rollback.”</li></ul><p>To scale, you want standardisation. But to be useful, you have to support the messy reality of how people actually work.</p><p>And that’s where things get tricky.</p><h3>The Combinatorial Explosion</h3><p>Traditionally, the software engineering answer to “every customer is different” is <strong>configuration</strong>.</p><p>You build a settings page. Then you add a toggle for log format. Then a dropdown for notification style. Then a regex field so customers can map their internal service names.</p><p>I call this <strong>Configuration Hell</strong>.</p><p>Every new toggle increases the possible state space of your system. Your clean, opinionated backend slowly turns into a Rube Goldberg machine of if/else statements. Testing becomes harder, because no one can reproduce the exact combination of settings that Customer C happens to be using.</p><p>But the real problem appears after you ship.</p><p>Once configuration becomes complex enough, you’re forced into an uncomfortable choice:</p><p><strong>Diabolical UX</strong> You expose the full control panel to customers. They stare at a cockpit of YAML files, regex patterns, and nested options, realise it will take weeks to integrate, and quietly abandon the product.</p><p><strong>Accidental Consultancy</strong> To prevent that churn, your engineers jump on onboarding calls and write the configuration for them. Suddenly your scalable SaaS product starts behaving suspiciously like a high-priced consulting business.</p><p>Neither outcome scales.</p><p>To build an AI teammate that actually works across different environments, we had to stop asking customers to configure the system and start building software that <strong>figures out the configuration itself</strong>.</p><h3>The Rigidity Trap</h3><p>Traditional software is <strong>rigid</strong>. It’s a deterministic set of instructions that executes exactly as written.</p><p>That rigidity is normally a strength. Deterministic systems are predictable, safe, and easy to reason about.</p><p>But they rely on one assumption: that the world they interact with is predictable.</p><p>Production environments aren’t.</p><p>Context matters enormously.</p><p>A <strong>500ms latency spike</strong> on a high-frequency trading system is catastrophic. The same spike on a background image processing job is completely normal.</p><p>You <em>can</em> encode those distinctions in a rule engine, but only by adding more and more configuration. Eventually you’re back in Configuration Hell.</p><p>In other words, you’re trying to solve a <strong>fuzzy human problem</strong> with rigid logic.</p><h3>Enter the Fuzzy Logic Layer</h3><p>If you want software to interpret messy operational context without requiring endless configuration, you need a system designed to reason about ambiguity.</p><p>You need a Large Language Model.</p><p>But if you just pipe a log dump into a standard LLM prompt and ask for a summary, you get a parlour trick. Debugging production is never a single-shot question. It requires a reasoning loop. An on-call engineer doesn’t just look at an error spike and instantly know the answer; they look at a Datadog graph, form a hypothesis, query GitHub for recent PRs, and <em>then</em> make a decision.</p><p>That is why we didn’t just wrap an LLM in a UI. We built an <strong>Agent</strong>. By giving the model the autonomy to iteratively query databases, evaluate the response, and pull secondary context before making a routing decision, we aren’t just summarizing data — we are automating the investigative workflow.</p><p>Now, at this point, any experienced SRE reading this is probably rolling their eyes — and fairly so. Agents are probabilistic systems. They hallucinate. Letting one run freely inside a production environment would be irresponsible.</p><p>But we realised something important: the probabilistic part of the system doesn’t have to <strong>execute</strong> anything.</p><p>It only has to <strong>interpret</strong>.</p><p>At Ewake, the Agent acts as a <strong>Semantic Investigator</strong>. It sits between the messy, unstructured reality of production systems and the deterministic tools engineers rely on.</p><p>The fuzzy logic lives in interpretation and routing. The rigid logic stays in execution.</p><p>That separation turns out to be extremely powerful. Here is a high-level look at how it works:</p><h3>Navigating the Data Sprawl</h3><p>Consider a simple Error 500 alert.</p><p>In traditional automation systems, retrieving useful context requires explicitly coded integrations and mapping logic:</p><blockquote><em>If database lock appears → check recent ORM commits → query deployment logs → correlate metrics.</em></blockquote><p>But production environments rarely follow predictable patterns. Logs may be structured or unstructured. Engineers might discuss an issue in a Slack thread long before it appears in monitoring dashboards.</p><p>An Agent can ingest all of that information directly: logs, pull requests, alerts, and conversations. It interprets relationships across different data formats without requiring engineers to explicitly encode every mapping rule.</p><p>The goal isn’t to eliminate integrations entirely. Systems like Datadog or GitHub still provide the raw data.</p><p>What the Agent replaces is the brittle <strong>logic layer</strong> that normally tries to stitch those systems together.</p><h3>The Handshake: Forcing Structure on the Probabilistic</h3><p>Of course, you can’t just drop a probabilistic model into production infrastructure and hope for the best.</p><p>The challenge is forcing a system that speaks natural language to behave safely inside a deterministic platform.</p><p>Our solution is a two-layer guardrail system: <strong>Shape</strong> and <strong>Sanity</strong>.</p><h4>Layer 1: Shape (Structured Outputs)</h4><p>When the Agent decides on an action — for example, querying Datadog for recent error logs — it isn’t allowed to respond with free-form text.</p><p>Instead, it must produce a strictly structured output defined by a schema. We use utilities like Zod to enforce that structure, leveraging the schema descriptions to pass explicit instructions to the model.</p><p>Imagine the input for a simple log-retrieval tool:</p><pre>inputSchema: z.object({<br>  query: z.string().describe(&#39;The Datadog search syntax query. Include specific facets like @service or @status.&#39;),<br>  from: z.string().describe(&#39;The ISO 8601 start timestamp for the search window.&#39;),<br>  to: z.string().describe(&#39;The ISO 8601 end timestamp for the search window.&#39;)<br>})</pre><p>If the LLM tries to return a conversational paragraph, or hallucinates a generic date instead of a strict ISO timestamp, the validation catches it and rejects the payload automatically. This ensures our deterministic code never has to interpret natural language when it expects a strictly typed API payload.</p><h4>Layer 2: Sanity (Qualitative Validation)</h4><p>Structured outputs solve the <strong>syntax problem</strong>, but not the <strong>truth problem</strong>.</p><p>An LLM can still confidently fabricate a service name that fits the schema perfectly.</p><p>To catch that, we run qualitative validation using evaluation tools in our agent framework, Mastra. These evaluators compare the Agent’s output against the original context to detect hallucinations or unsupported claims.</p><p>If the evaluation fails, the output is rejected and the system retries with adjusted reasoning.</p><p>In practice, this creates a controlled loop:</p><p>Probabilistic reasoning → structured output → validation → deterministic execution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gd-3ToHvkrWODhMDDllsiA.png" /></figure><p>Only validated outputs are allowed to trigger downstream actions.</p><h3>The 60-Second Trade-off</h3><p>There’s another objection engineers raise immediately: <strong>latency</strong>.</p><p>LLMs are slow. An Agent investigating an incident might take close to a minute to ingest logs, review recent pull requests, and generate a structured summary.</p><p>In traditional software, 60 seconds is a lifetime.</p><p>But in incident response, 60 seconds is about how long it takes an on-call engineer to wake up, find their glasses, and open Slack.</p><p>By the time they start reading the alert, the Agent may already have scanned thousands of log lines, correlated recent commits, and highlighted the most likely anomaly.</p><p>Trading a minute of machine time to save half an hour of human investigation is usually a very good deal.</p><h3>Learning From the Mess</h3><p>There’s another important side effect of this architecture: it allows us to learn from our mistakes.</p><p>Every time the Agent misclassifies an alert, the validation layer records the failure. Every time an engineer confirms or rejects the Agent’s investigation, that feedback becomes part of an evaluation dataset.</p><p>Over time, this produces something extremely valuable: a corpus of <strong>real production incidents and their resolutions</strong>.</p><p>Rather than relying forever on general-purpose foundation models forever, we can use that dataset to fine-tune smaller, faster models specialised for production debugging.</p><p>In other words, the system doesn’t just investigate incidents. It gives us the ability to learn from them.</p><h3>The Economics of Laziness (and On-Call Sanity)</h3><p>Of course, none of this would matter if engineers couldn’t trust the system during an outage.</p><p>For that reason, our Agent is deliberately constrained.</p><p>It is not an autonomous operator. It is an <strong>investigator</strong>.</p><ul><li><strong>Read-only by default.</strong> The Agent gathers context and proposes explanations, but it doesn’t trigger rollbacks or deploy fixes automatically.</li><li><strong>Deterministic observability.</strong> Every prompt, context window, and tool call is internally logged. If the Agent makes a bad inference, we can trace exactly what information it saw and where the reasoning went wrong.</li></ul><p>The goal is simple: reduce <strong>Mean Time to Insight</strong>, not automate every action.</p><p>During an outage, the hardest problem isn’t running a command. It’s figuring out <em>which</em> command to run.</p><h3>Conclusion: It’s Still Just Plumbing</h3><p>We didn’t build this architecture because we wanted to ride the AI hype cycle.</p><p>We built it because the alternative was spending years writing configuration logic for every strange observability setup in the wild.</p><p>The real engineering challenge over the next few years isn’t training slightly smarter foundation models. It’s building the <strong>systems that safely integrate probabilistic reasoning into deterministic infrastructure</strong>.</p><p>Agents give us a practical way to do that.</p><p>They let us replace thousands of brittle configuration rules with a system that can interpret messy environments directly, while still keeping execution inside a deterministic safety cage.</p><p>It’s not a digital super-brain. It’s just a fuzzier if statement for a messy world.</p><p><strong>Ewake isn’t coming for your job; it’s coming for your YAML.</strong> And compared to maintaining another 5,000-line YAML configuration file, that’s a trade-off we’re happy to make.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb563696626b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/ewake-isnt-coming-for-your-job-it-s-coming-for-your-yaml-fb563696626b">Ewake isn’t coming for your job; it’s coming for your YAML</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How engineers survive without runbooks during incidents]]></title>
            <link>https://medium.com/ewake-ai/how-engineers-survive-without-runbooks-during-incidents-23368b8c4f19?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/23368b8c4f19</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-sre]]></category>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Poonemokari]]></dc:creator>
            <pubDate>Fri, 27 Feb 2026 09:51:30 GMT</pubDate>
            <atom:updated>2026-02-27T09:51:30.566Z</atom:updated>
            <content:encoded><![CDATA[<h4>Maybe Runbooks Were Never the Answer</h4><h4>Runbooks have always been a bit of a necessary pain.</h4><p>Everyone agrees they’re important, but no one enjoys creating them.</p><p>They usually get written after something breaks.</p><p>Then they sit in a doc somewhere… slowly drifting out of reality and at some point outdated.</p><p>AI helps in writing them, you can just explain what you want and then have very well structured runbook.</p><p>So now they are clean, probably “updated”, but the core issue never changed:</p><p>We’re still trying to capture a living, evolving production system in a static set of steps.</p><p>And to be fair, runbooks were never just documentation.</p><p>They’ve also acted as safety mechanisms: defining what actions are considered <strong>safe</strong> during stress, reducing variance in response, and giving teams confidence that recovery paths are understood.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3NkV7baNm3b4sluPWi9XuQ.jpeg" /></figure><h3>The Real Question Isn’t “Better Runbooks”</h3><p>With AI agents becoming part of how we build and operate systems, something subtle is shifting.</p><p>Incidents are no longer just something engineers walk through manually using predefined instructions.</p><p>We’re starting to rely on systems that can:</p><ul><li>look at <strong>what’s happening now</strong></li><li>connect signals across layers</li><li>reason about possible causes</li><li>suggest or take actions</li></ul><p>Not to replace engineers, but to help them <strong>understand faster</strong>.</p><p>To remove the need to mentally reconstruct the system during an outage.</p><p>And once you have that…</p><p>You start wondering:</p><p><em>“Why are we still writing step-by-step runbooks at all?”</em></p><p>Runbooks assume the future is predictable and they are built on an assumption: <br><em>“If we document enough scenarios, we’ll be ready.”</em></p><p>But incidents emerge from interactions between components that were never meant to fail together.</p><p>That’s why even well-written runbooks often fail in the moments we need them most.</p><p><strong>They’re static answers to dynamic problems.</strong></p><h3>What Changes in an Agent-Driven World</h3><p>As AI agents become more fited in production workflows, the role of documentation starts to shift.</p><p>Instead of writing instructions for humans to follow step by step, we can start structuring knowledge that agents can use — within clearly defined safety boundaries — to:</p><ul><li>interpret situations</li><li>explore options</li><li>adapt as new signals appear</li></ul><p>Not:</p><p>“If X happens, do Y.”</p><p>But:</p><ul><li>how systems relate</li><li>what “healthy” looks like</li><li>where risks usually emerge</li><li>what tradeoffs exist during recovery</li><li>which actions are safe under which conditions</li></ul><p>This isn’t about giving agents open-ended autonomy.</p><blockquote>It’s about moving from procedural instructions to structured operational constraints:</blockquote><ul><li>what actions are allowed</li><li>what risks are acceptable</li><li>when escalation is required</li></ul><p>That’s not a traditional runbook.</p><p>That’s operational understanding encoded as <strong>guardrails</strong>.</p><p>Once knowledge is structured in a way that agents can use dynamically, the traditional runbook becomes less central.</p><p>The primary consumer of operational knowledge is no longer a human reading during an incident.</p><p>It’s a system helping make sense of reality in real time.</p><p>The mindset shift is subtle but important:</p><p>We stop thinking about writing runbooks, even AI-generated ones.</p><p>And start thinking about building knowledge that can be used.</p><h3>The Future Isn’t Better Runbooks</h3><p>It’s better <strong>operational memory</strong>.</p><p>Better context or better ways for humans and agents to collaborate during uncertainty.</p><p>The goal isn’t to automate troubleshooting entirely.</p><p>It’s to avoid forcing humans to rely on rigid, outdated instructions when navigating complex failures.</p><p>So the next step forward isn’t improving runbooks.</p><p><strong>It’s evolving them.</strong></p><blockquote>From static instructions to adaptive understanding.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23368b8c4f19" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/how-engineers-survive-without-runbooks-during-incidents-23368b8c4f19">How engineers survive without runbooks during incidents</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fast Code or Fragile Systems]]></title>
            <link>https://medium.com/ewake-ai/fast-code-or-fragile-systems-2ba30ed876e2?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/2ba30ed876e2</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-reliability]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Poonemokari]]></dc:creator>
            <pubDate>Wed, 11 Feb 2026 11:14:01 GMT</pubDate>
            <atom:updated>2026-02-11T11:22:20.830Z</atom:updated>
            <content:encoded><![CDATA[<h3>A few years ago, opening GPT-3, pasting a function, and watching a reasonable implementation appear felt almost magical.</h3><p>At the time, it was hard to imagine how quickly that feeling would become normal.</p><p>Today, AI-assisted coding is part of everyday engineering. The question is no longer <em>if</em> teams will adopt AI; that decision has already been made. The more interesting question now is <strong>where AI actually belongs in the engineering workflow</strong>.</p><p>Most engineers no longer see AI as a threat. It’s a force multiplier or a baseline raiser.</p><p>We’re seeing a new generation of code agents raise the baseline for software delivery. With tools like OpenAI Codex and Devin, teams can now ask an agent to implement a feature, wire it to existing services, generate tests, and iterate on feedback — tasks that previously required multiple handoffs across a sprint.</p><p>Humans acting as orchestrators, guiding, validating, and managing intelligent systems, is no longer a future concept. It’s already happening.</p><p>But there’s a deeper truth we don’t talk about enough.</p><h3>Most Engineering Time Is Not Coding</h3><p>Pure coding often accounts for only about <strong>16% of an engineer’s time</strong>.</p><p>The lack of investment in resolving real developer friction shows up clearly in Atlassian’s 2025 survey results: much of the remaining 84% of engineering time is lost to finding information, switching between tools, meetings, and coordination.</p><p>Code that never survives production is not velocity; it’s friction.</p><p>Real engineering speed isn’t about how fast code is written but it’s about how reliably it runs in production.</p><h3>Engineers Spend Most of Their Time Between Tools</h3><p>If we look closely at how engineers actually work, especially under pressure, the pattern is clear.</p><p>We jump from logs to traces.</p><p>From metrics back to code.</p><p>From dashboards to incident timelines.</p><p>We correlate signals, form hypotheses, test them, revise them, and repeat. Understanding doesn’t live in a single place; it’s built <strong>between tools</strong>.</p><p>Most AI agents today don’t operate there.</p><p>They live inside an IDE, a chat window, or a ticketing system. They’re great at generating code, but they don’t understand <em>why</em> that code failed in production. They don’t see system behavior, operational history, or real business impact. And without that context, they can’t meaningfully help when things go wrong.</p><h3>That’s Why AI Needs to Understand Production Env</h3><p>If we want to unlock the full value of AI agents, they can’t stop at code.</p><p>They need to understand:</p><ul><li>the production environment</li><li>the system architecture</li><li>observability signals</li><li>business logic and constraints</li></ul><p>An effective AI agent should be able to follow an issue from a production alert, through system behavior, all the way back to the root cause in code — and forward again to a safe, confident fix.</p><p>AI should reduce incidents, not introduce new ones. It should help teams ship with confidence and not just speed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kD-SaKc_s-q3_l4I8WG0Tg.png" /></figure><h3>The Future: AI Where Engineers Actually Work</h3><p>If engineering happens between tools, then AI agents have to live there too.</p><p>They need to be a continuous layer, the one that understands context, connects signals, and helps engineers make better decisions in real time, especially in production, where the stakes are highest.</p><p>That’s the future we believe in at <a href="http://ewake.ai/"><strong>ewake.ai</strong></a>.</p><p>And it’s the future engineering teams deserve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ba30ed876e2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/fast-code-or-fragile-systems-2ba30ed876e2">Fast Code or Fragile Systems</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Anatomy of an Agent (Spoiler: It’s Still Just Code)]]></title>
            <link>https://medium.com/ewake-ai/anatomy-of-an-agent-spoiler-its-still-just-code-9c8d5d7b777f?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/9c8d5d7b777f</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Cian Duffy]]></dc:creator>
            <pubDate>Tue, 03 Feb 2026 10:21:48 GMT</pubDate>
            <atom:updated>2026-02-03T10:21:46.879Z</atom:updated>
            <content:encoded><![CDATA[<p>AI agents are hot at the moment. I first heard the word “agentic” less than three years ago, and today it feels like I can’t escape it. It feels like the actual meaning of the term is getting lost in the hype noise. Is an agent a digital employee? Is it some kind of machine spirit that inhabits my over-engineered AI toaster?</p><p>This article is an attempt to cut through the hype and noise, and to give a human-readable, grounded perspective on what an AI agent actually is, from a traditional software engineer’s perspective.</p><p>A little note about me: I come from a very traditional software engineering background. Before I joined <a href="https://www.ewake.ai/">Ewake</a> as a founding engineer, I spent nearly 8 years working for a tech giant with a bridge for its logo, mainly on an embedded C++ app for videoconferencing endpoints. I’m as cynical about the AI hype machine as anyone, but rather than dismissing it outright or becoming a dyed-in-the-wool vibe coder, I’ve developed a feeling for where this new thing fits.</p><h3>Another Software Revolution(?)</h3><p>Last summer I watched Andrej Karpathy’s talk <a href="https://www.latent.space/p/s3">Software 3.0: Software in the Age of AI</a>, and I found it persuasive. In it, he proposed three generations of software:</p><ul><li><strong>Software 1.0:</strong> Traditional Software (Written by humans, explicit logic).</li><li><strong>Software 2.0:</strong> Machine Learning (ML models with learned weights).</li><li><strong>Software 3.0:</strong> Prompts (Natural language instructions compiled by an LLM).</li></ul><p>In his <a href="https://karpathy.medium.com/software-2-0-a64152b37c35">Software 2.0 essay</a>, Karpathy observed that Software 2.0 was “eating” Software 1.0 at Tesla. The parts of the system’s functionality that were the result of human-written logic were being replaced with models and weights.</p><p>For brevity, I’ll call traditional software <strong>Type 1</strong> and LLMs <strong>Type 3</strong>.</p><p>He extends this argument, predicting that Type 3 “software as prompts” will do a similar job, gradually taking over more and more of the functionality of the codebase, without fully eliminating the other two.</p><p>The important thing to takeaway here is that Type 1 Code didn’t go away — the proportions just changed. This is the case with AI agents. An Agent is simply a robust chunk of Type 1 code wrapping a piece of Type 3 code.</p><p>For the sake of this article I’ll anthropomorphise the agent, but in reality, it’s just probabilistic code that we have to manage with traditional engineering.</p><h3>The Brain</h3><h4><strong>1. The Loop</strong></h4><p>The core of an AI agent is a loop. The term that the industry is settling on is “ReAct” agent (Reflect and Act). The agent reflects on its situation, then takes an action, then reflects on the result of that action, then takes another action, etc.</p><p>Fundamentally, this is a <strong>REPL (Read-Eval-Print Loop) </strong>— a familiar sight to any software engineer. The difference here is that there’s a chunk of probabilistic code involved that makes the decisions, but the concept stands.</p><p>As AI engineers we have the option of rolling our own agent loop using primitives like <a href="https://www.langchain.com/langgraph">LangGraph</a> or <a href="https://ai-sdk.dev/">Vercel’s AI SDK</a><strong>.</strong> However, in the last year and change we’ve seen the rise of more opinionated frameworks, from high-level abstractions like <a href="https://www.crewai.com/">Crew AI</a>, to code-centric tools like <a href="https://ai.pydantic.dev/">Pydantic AI</a> and <a href="https://mastra.ai/"><strong>Mastra</strong></a> (our current weapon of choice). This ecosystem is still young but it’s maturing rapidly.</p><p>Here is what that loop actually looks like in practice. You can see how the probabilistic “Brain” is completely surrounded by deterministic Type 1 processes.</p><figure><img alt="A flow chart showing the reasoning loop of a ReAct agent" src="https://cdn-images-1.medium.com/max/1024/1*PojeZ9Sq-qwwDFvWoqeTdg.png" /></figure><h4>2. The Internal Dialogue</h4><p>You might hear the analogy that an Agent is “two LLMs talking to each other.” That sounds like the end of <a href="https://www.youtube.com/shorts/Q9UDVyUzJ1g"><em>Her</em> (2013)</a>, but in reality, it’s just a software pattern called <strong>Actor-Critic</strong>.</p><p>Why do we do this? Because LLMs are prone to hallucinations. They are confident liars. However, research shows that LLMs are significantly better at <em>critiquing</em> logic than generating it.</p><p>So, we treat the Agent like a development team:</p><ul><li><strong>Call 1 (The Actor):</strong> The “Junior Dev.” It writes the code or generates the plan.</li><li><strong>Call 2 (The Critic):</strong> The “Senior Dev.” It reviews the plan, checks for bugs, and rejects it if it looks wrong.</li></ul><p>It’s not a split personality; it’s just running a code review in natural language before we let the code run in production.</p><h4>3. The Memory</h4><p>Here is the headache: LLMs have no memory. They are stateless.</p><p>To create a coherent conversation, we have to perform a massive “State Restoration” on every single turn. We have to re-inject the user’s prompt, the previous replies, the tool outputs, and the system instructions every time we loop.</p><p>It’s an inventory management problem. We are effectively re-installing the Operating System for every single iteration. And since we pay by the token, this gets expensive fast.</p><p>“Context Engineering” isn’t magic; it’s just ruthless compression to ensure we don’t go broke while debugging a single alert. Honestly, this is where 80% of the actual engineering work in building agents lives right now — figuring out exactly what data to show the model at any given moment to get the best result.</p><h3>The Hands</h3><p>Right now, we have a brain in a jar. It can reason, but it has no hands. It can’t fetch your Datadog logs and it can’t open a pull request. It is trapped in the text box.</p><p>To fix this, we give the Agent <strong>Tools</strong>. Think of these like API wrappers for the illiterate. We create a registry of functions (Type 1 code) and describe them to the LLM.</p><p>When the Agent wants to check an incident, it doesn’t run the command. It writes a “Work Order” in JSON.</p><p>JSON</p><p>Agent: { &quot;tool&quot;: &quot;get_logs&quot;, &quot;service&quot;: &quot;checkout&quot;, &quot;level&quot;: &quot;error&quot; }</p><blockquote><em>Runtime: “I see you want logs. I will execute that safely and paste the result back to you.”</em></blockquote><p>This is where <a href="https://modelcontextprotocol.io/docs/getting-started/intro"><strong>MCP (Model Context Protocol)</strong></a> comes in. Think of it as USB-C for AI. Instead of writing custom drivers for every single tool, MCP provides a standard plug. It allows our probabilistic Type 3 code to talk to our rigid Type 1 infrastructure without breaking things.</p><h3>The Handshake</h3><p>There is a conflict at the interface between our deterministic logic and the probabilistic LLM. How do we make them play nicely together?</p><p>The answer, as is so often the case, is <strong>defensive programming</strong> and <strong>schema validation</strong>.</p><p>We don’t trust the agent. We force its output into a strict structure. If the LLM outputs a string where we expect to have an int, the Type 1 code catches it and either forces a retry or throws an error.</p><p>This is all handled quite natively by the agent frameworks I mentioned earlier, using well-known utilities like <a href="https://zod.dev/">Zod</a> for schema enforcement.</p><h3>To Wrap Up</h3><p>People are excited about the potential of Agents, and rightly so. But we need to stop treating them like magic and start treating them like what they are: a new type of application architecture.</p><p>At Ewake, we bet on this architecture because production environments present the ultimate Type 3 problem. No two incidents are the same. You cannot write a static if/else block for &quot;the database is slow because a noisy neighbour is hogging CPU.&quot; That requires reasoning.</p><p>But we also can’t let an LLM hallucinate a DROP TABLE command. That requires the safety of Type 1 code.</p><p>Agents allow us to bridge the gap. We use the LLM to understand the messy, chaotic reality of an outage, and we use traditional software engineering to ensure the response is safe, valid, and deterministic.</p><p>So, yes, the hype bubble will burst. The AI Toasters will vanish. But this pattern (probabilistic reasoning inside a deterministic cage) is part of the future of how we build software. It’s still code. It’s just a new pattern.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KLyveGkllZdj_xs_1OIKeg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c8d5d7b777f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/anatomy-of-an-agent-spoiler-its-still-just-code-9c8d5d7b777f">Anatomy of an Agent (Spoiler: It’s Still Just Code)</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[No More Pager Fatigue: Intelligent Alerting for Work-Life Balance]]></title>
            <link>https://medium.com/ewake-ai/no-more-pager-fatigue-intelligent-alerting-for-work-life-balance-9d3cfd87efd7?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/9d3cfd87efd7</guid>
            <dc:creator><![CDATA[Omid Gosha]]></dc:creator>
            <pubDate>Tue, 08 Jul 2025 09:09:38 GMT</pubDate>
            <atom:updated>2025-07-17T09:54:31.617Z</atom:updated>
            <content:encoded><![CDATA[<h3>Ewake.ai — AI production teammateNo More Pager Fatigue: Intelligent Alerting for Work-Life Balance</h3><p>Anyone who’s ever been on-call knows the feeling: it’s 3 a.m., your phone buzzes, and you jolt awake — only to find a false alarm. Or a low-priority metric spike. Or worse: ten near-identical alerts that all trace back to the same deploy.</p><p>It’s more than frustrating. It’s a signal architecture problem, one that’s quietly burning out some of the industry’s most critical teams.</p><p>For developers, the constant stream of alerts, urgent or not, chips away at momentum during the day and lingers into nights and weekends when you’re on call. It’s the sense that you’re never fully off, that any blip might trigger a notification, that you’re always one step away from being pulled back in.</p><p>This isn’t just a nuisance. It’s a signal design problem — and it’s burning people out.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wLNTZvy3n4Y30Exrp9KJcA.jpeg" /><figcaption>Ewake.ai — AI production teammate</figcaption></figure><h3>The Human Cost of Noisy Systems</h3><p>As infrastructure grows more modular and distributed, alerting complexity increases exponentially. Microservices, ephemeral resources, real-time pipelines — all generate signals, all shift over time. But alerting logic often doesn’t keep up.</p><p>Most setups still rely on static thresholds, basic if-this-then-that logic, and page-everything escalation chains. As a result:</p><ul><li>Engineers get paged for non-urgent noise</li><li>Context is split across five dashboards and three Slack channels</li><li>Teams become desensitized to alerts altogether</li></ul><p>It’s a recipe for cognitive overload. And while this has long been treated as a necessary evil of production work, that’s starting to change.</p><h3>The Industry Is Moving — Slowly</h3><p>Across the ecosystem, a shift is underway. From platform providers to incident tooling startups, we’re seeing an increased focus on reducing noise and improving signal quality.</p><p>Modern observability platforms are beginning to introduce anomaly-aware alerting, dynamic baselining, and root-cause correlation. Incident response tools now group alerts, suppress redundant notifications, and even offer AI-assisted postmortems. The goal? Minimize alert fatigue without compromising visibility.</p><p>But there’s still a gap between what’s technically possible and what’s actually implemented on the ground. Many teams remain stuck with over-alerting, unclear ownership, and manually curated escalation policies.</p><h3>What Smarter Alerting Actually Looks Like</h3><p>The future of alerting isn’t just about better thresholds, it’s about <strong>contextual intelligence</strong>.</p><p>That means:</p><ul><li><strong>Dynamic suppression</strong>: Alerts that auto-silence during known deploy windows, or when signals remain within historical variance.</li><li><strong>Causal grouping</strong>: Instead of surfacing 30 alerts from downstream services, group them under the actual root cause — a recent change in the checkout API, for instance.</li><li><strong>Risk-aware prioritization</strong>: Combine service tiering, blast radius modeling, and past incident data to decide which issues get escalated, and which don’t need a human at all.</li><li><strong>Context enrichment</strong>: Every alert should come with metadata — recent changes, linked playbooks, and ownership info — by default, not as an afterthought.</li></ul><p>These aren’t theoretical. The tooling exists. What’s missing, in many cases, is the architecture and mindset to integrate them coherently.</p><h3>Why This Matters — And What It Means in Practice</h3><p>This isn’t just a tooling gap — it’s a design flaw in how we think about operational load. And it’s something we care about deeply.</p><p>Ewake was founded by engineers who’ve built and maintained large-scale systems where alert storms weren’t rare, they were routine. Where false positives trained teams to mistrust their tooling. Where “alert fatigue” was more than a phrase — it was a normalized part of team culture.</p><p>That experience shaped our core principle:</p><p><strong>Incident systems should be designed with human sustainability in mind.</strong></p><p>It’s not just about preventing downtime, it’s about building systems that know when to speak up, when to stay quiet, and how to help when it matters.</p><p>In practice, that means building infrastructure that understands baseline behavior, adapts over time, and surfaces only the most relevant signals — enriched with the context engineers need to act confidently. It means building incident layers that don’t just push pages, but help teams triage, prioritize, and resolve faster — without flooding them with noise in the process.</p><p>This is the perspective we bring to the table. And while there’s still work to do, across the industry, not just within any single product, the direction of travel is clear.</p><h3>Toward a More Sustainable On-Call Culture</h3><p>Pager fatigue isn’t a badge of honor. It’s a sign that the system, not the engineer, is under-optimized.</p><p>And now, with the tools we have, we can finally do something about it. AI, adaptive signals, automated enrichment — these aren’t magic. They’re how we start designing on-call for the humans who carry it.</p><p>Because the future of reliability isn’t just faster response. It’s <strong>fewer wake-ups, better signals, and healthier teams.</strong></p><p>Smarter alerting is one piece of a bigger puzzle: designing systems that scale smoothly without overloading the humans behind them — a direction that’s core to Ewake’s mission to make production more reliable <em>and</em> more humane.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d3cfd87efd7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/no-more-pager-fatigue-intelligent-alerting-for-work-life-balance-9d3cfd87efd7">No More Pager Fatigue: Intelligent Alerting for Work-Life Balance</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond the Demo: Real-World Problems with LLM API Implementation]]></title>
            <link>https://medium.com/ewake-ai/beyond-the-demo-real-world-problems-with-llm-api-implementation-862ab920e15b?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/862ab920e15b</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[best-practices]]></category>
            <dc:creator><![CDATA[Omid Gosha]]></dc:creator>
            <pubDate>Tue, 08 Jul 2025 09:04:46 GMT</pubDate>
            <atom:updated>2025-06-11T13:33:40.330Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why Put an LLM API Call in Your Code?</h3><p>One powerful way to think about using an LLM API in your code is this: <strong>you’re outsourcing a piece of logic,</strong> sometimes simple, sometimes deeply complex.</p><p>Imagine you’re building a product and there’s a chunk of logic that, in an ideal world, with enough time, data, and compute, you’d just build yourself. Maybe it’s as straightforward as mapping user intent,</p><pre>&quot;if dog, choose dog; if cat, choose cat&quot;</pre><p>or maybe it’s something far more involved, like image classification, summarising customer messages, or transcribing and interpreting voice.</p><p>What LLMs let you do is <strong>delegate that chunk of functionality</strong>. You send in some text, a prompt, maybe some metadata or even multimodal input, and the API returns an intelligent response, this can be a decision, a summary, a label, a suggestion. And while it’s powered by a massive neural network under the hood, it’s often helpful to think of it as a <strong>virtual code block that speaks natural language</strong>.</p><p>You’re not replacing all of your logic with magic. Instead, you’re strategically offloading tasks that would be too time-consuming or expensive to hardcode yourself.</p><blockquote>That is precisely what makes LLM APIs a <strong>huge leverage point</strong>, especially for solo devs or small teams. Suddenly, you’re shipping features that used to require a dedicated NLP engineer or a whole software engineering team!</blockquote><p>That’s the key trade-off here: <strong>instead of building, training, and maintaining custom logic</strong>, you <strong>call out</strong> to a hosted intelligence, and let it do part of the work. <strong>It’s a bit like hiring a powerful but fuzzy-thinking assistant: fast, capable, and scalable, though not always predictable</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y8yq3JK6_rgq4rFw4ioPVQ.png" /></figure><p>And this trade-off is especially powerful for MVPs and startups. Want to build a prototype that classifies, recommends, parses, or chats? Plug in an LLM, wrap a UI around it, and suddenly you’re shipping product. You’re not cutting corners, you’re <strong>accelerating what would otherwise take weeks or months</strong>.</p><p>Whether it’s for agent logic, data labeling, semantic search, or user interface enhancements, making the decision to integrate an LLM isn’t about chasing hype. It’s about choosing the <strong>right abstraction layer</strong> for your current constraints and ambitions.</p><h3>What Changes When You Integrate an LLM Call?</h3><p>So you’ve made the decision: you’re going to include an LLM API call in your code. It makes sense, you’ve weighed the trade-off: rather than building out a massive chunk of logic yourself, you’re outsourcing it to a model that can do it better, faster, or just more affordably at your current scale.</p><p>But it is precisely this decision that <strong>changes the game.</strong> You’re no longer writing purely deterministic code, you’re <strong>writing code that talks to intelligence</strong>. That comes with new constraints, new costs, and a few big mindset shifts.</p><p>Those are the three biggest changes that are important to be aware of:</p><h3>1. Cost Is Now a Core Part of Your Architecture</h3><p>With traditional code, execution cost was mostly invisible: CPU cycles, RAM usage, maybe some bandwidth. But with LLMs, <strong>every call translates into real monetary costs</strong>, and those costs may quickly scale with input/output size and model quality.</p><p>Here’s a rough breakdown:</p><ul><li>🪶 <em>Lightweight models</em>: AWS’s <strong>Titan Text Lite</strong> or <strong>Mistral-based models</strong> can cost around <strong>$0.03 per million input tokens</strong>.</li><li>⚡ <em>Powerful models</em>: Models like <strong>Claude 3.5 Sonnet</strong> or <strong>GPT-4 Turbo</strong> can range from <strong>$0.50 to $3+ per million input tokens</strong>.</li><li>⚠️ <em>Token math</em>: A typical prompt-response pair can consume <strong>10K–15K tokens total</strong>, especially if you’re working with long context (e.g., documents, emails, chat history).</li></ul><p>So your system architecture now has to factor in <strong>financial cost per request</strong>, and that varies depending on:</p><ul><li><strong>Which model you use</strong> (quality vs. price)</li><li><strong>How verbose your prompts and responses are</strong>,</li><li><strong>How frequently you call the model</strong>.</li></ul><p>It’s a new kind of performance tuning: <strong>balancing quality vs. cost</strong>. In some cases, a more affordable model is good enough, especially when it comes to keyword extraction, classification, or light summarization. Other times, the accuracy gain of a bigger model is worth the investment.</p><h3>2. The Output Is Non-Deterministic</h3><p>This is one of the most fundamental changes to how your code behaves. Traditional functions always produce the same output for a given input. But with LLMs? <strong>Same prompt, different day — possibly different answer</strong>.</p><p>That’s not necessarily a flaw, it’s how creativity, generalization, and nuance work. On the other hand, It means you need to <strong>design your system defensively</strong>:</p><ul><li>If you’re building a summarizer or a chatbot, variation is fine, even expected.</li><li>If you’re building decision-making logic or agents that act based on LLM output, <strong>you need guardrails</strong>.</li></ul><p>Even with a clear prompt, there’s always a slight chance, 5%, 2%, maybe less, that the model says or decides something incorrect or even irrelevant.</p><p>We’ll cover how to deal with this (e.g., retries, validations, constraint prompting) in the next section.</p><h3>3. Response Time Becomes a Bottleneck</h3><p>Last but not least: <strong>LLMs aren’t instant</strong>. You’re making a network call to a large model that may be distributed across multiple GPUs in a remote data center. That adds latency.</p><p>Depending on the model and complexity of your prompt:</p><ul><li>Small models might respond in <strong>under 1 second</strong>,</li><li>Mid-range models take <strong>2–6 seconds</strong>,</li><li>Larger models (or longer outputs) can take <strong>10–30 seconds,</strong> or more.</li></ul><p>This affects how you structure user flows: Do you show a loading spinner? Do you stream responses? Do you need fallback behaviour if the model takes too long? Should you pre-cache predictions or use async background calls?</p><p>Suddenly, your backend isn’t just running logic; it’s waiting on someone else’s very smart, very slow intern.</p><h3>Deep Dive: Solving for Response Time and Non-Determinism</h3><p>Once you start building with LLMs in production, the magic wears off quickly; not because the models are any less impressive, but because the engineering realities start to kick in.</p><p>Therefore, we will take a deep dive into <strong>two of the biggest practical challenges of LLM-integrated engineering</strong>: response time and non-deterministic output.</p><h3>1. Tackling Response Time</h3><p>As the co-founder of <a href="http://ewake.ai/">Ewake.ai</a>, I’ve been deeply involved in building AI agents powered by large language models. One of the most persistent and complex challenges we’ve faced is managing response time, not just to deliver a smooth user experience, but also to ensure efficient system architecture and cost control.</p><p>Based on what we’ve learned through this journey, here are the key strategies that have proven most effective:</p><h3>A. Iterate Across Models and Regions</h3><p>If your system doesn’t rely on a specific model (like GPT-4 or Claude 3), you can implement <strong>model rotation strategies</strong>. This means calling different models based on:</p><ul><li>Current latency benchmarks,</li><li>API rate limits,</li><li>Regional availability.</li></ul><p>This not only improves average latency but also avoids hitting the rate limits of a single provider or endpoint. Some LLM providers even offer multi-model endpoints or routing logic you can build on top of.</p><h3>B. Keep Prompts Short. Seriously.</h3><p>This one seems obvious. But what’s less obvious is that <strong>prompt length increases latency non-linearly</strong>. Doubling your prompt length won’t just double your latency, it could <strong>triple or quadruple</strong> it depending on how much context the model has to parse.</p><p>Plus, longer prompts risk triggering known LLM weaknesses like the <strong>“lost in the middle”</strong> phenomenon, where the model misses important information buried deep in the context.</p><p>Instead of one massive prompt with long chain-of-thought reasoning, <strong>break your tasks down into smaller, simpler calls</strong>. That way:</p><ul><li>Each call is faster,</li><li>The model is less likely to get confused,</li><li>You get more reliable, structured behaviour.</li></ul><p>This kind of “task decomposition” not only improves latency but often improves <strong>output quality</strong> as well.</p><h3>C. Avoid Confusing Prompts</h3><p>Here’s a less-discussed but surprisingly common issue: <strong>prompt confusion slows the model down</strong>.</p><p>At Ewake.ai, we ran into cases where the model would stall or timeout, and the root cause wasn’t model size, it was <strong>contradictory instructions</strong> in the prompt.</p><p>Example:</p><ul><li>You say: <em>“Output a JSON with fields A and B.”</em></li><li>Later in the same prompt, you give an example with fields <strong>A and C</strong>.</li></ul><p>Now the model’s stuck trying to resolve an internal conflict. It might retry internally, hesitate, or hallucinate an inconsistent output, all of which <strong>waste time</strong>.</p><p>To avoid this:</p><ul><li>Be <strong>precise and consistent</strong> with prompt structure.</li><li>Ensure there’s no mismatch between what you’re asking for and the examples you provide.</li><li>Avoid unnecessary complexity, clarity beats cleverness.</li></ul><h3>2. Dealing with Non-Deterministic Outputs</h3><p>Another fundamental aspect of working with LLMs is their inherent non-determinism. They don’t always produce the same output, even when given identical input. This variability is part of what makes these models so powerful, enab rich, dynamic responses. But it also introduces a layer of unpredictability, turning the system into something of a fuzzy black box.</p><p>Through our work, we’ve developed several effective strategies for embracing that fuzziness, without letting it compromise the integrity or reliability of our systems.</p><h3>A. Use Guardrails Inside the Prompt</h3><p>Before you even hit the API, the first line of defense is your <strong>prompt design</strong>.</p><p>This means:</p><ul><li>Giving <strong>clear instructions</strong> for what you expect (formatting, style, structure),</li><li>Being <strong>explicit about edge cases</strong>,</li><li>Using <strong>examples</strong> that reinforce the behaviour you want.</li></ul><p>If you’re generating structured output, whether it’s JSON, XML, or tool call, even <strong>minor phrasing errors</strong> in your prompt can cause unexpected drift. We’ve found that small prompt adjustments can make a <strong>surprisingly big difference</strong> in stability and accuracy:</p><ul><li><em>“Respond only with a JSON object containing fields A, B, and C.”</em></li><li><em>“Do not add any explanation or commentary.”</em></li><li><em>“Field C must always be a lowercase string, even if not found.”</em></li></ul><p>The clearer your prompt, the more consistent your output.</p><h3>B. Don’t Be Cruel. Add a Post-Processing Layer</h3><p>Even the best prompts can’t guarantee 100% perfect responses, because that’s not what these models are optimized for. So if you’re treating the LLM as a deterministic service, you’ll inevitably run into frustrating edge cases.</p><p>Instead, LLM can be considered as getting you <strong>80% down the road,</strong> then let a thin post-processing layer handle the rest.</p><p>At Ewake, whenever we use an LLM to generate structured data, we consistently follow this approach:</p><ul><li>Output <strong>validation</strong> (e.g., does it match schema?),</li><li>Logical <strong>consistency checks</strong> (e.g., do related fields align?),</li><li>Optional <strong>fallbacks or retries</strong> if the output doesn’t pass.</li></ul><p>This mindset, giving the LLM room to be imprecise, but building systems that handle it gracefully, leads to far more robust results.</p><h3>C. Think of LLMs as Temporary Scaffolding</h3><p>Finally, here’s a strategic mindset shift: <strong>your LLM API calls of today’s code, don’t have to be there tomorrow!</strong></p><p>Back in section one, we talked about using LLMs as a trade-off. a shortcut when you don’t have time, budget, or team bandwidth to implement something yourself.</p><p>But as your product evolves, <strong>you might replace some of those API calls</strong>:</p><ul><li>You start with one-shot prompting,</li><li>Then evolve to multi-step agent flows,</li><li>Eventually, you replace some of those calls with <strong>hardcoded logic</strong>, <strong>retrieval systems</strong>, or <strong>classic machine learning</strong> as your domain becomes clearer.</li></ul><p>That’s a good thing. It’s not about abandoning LLMs, it’s about using them wisely: where they help you go faster, and moving away from them when you gain confidence in other solutions.</p><h3>Wrap-Up: LLMs as Engineering Trade-Offs</h3><p>LLMs bring enormous power, the ability to drop in advanced language understanding, decision-making, and even reasoning with just an API call. But they also shift how we think as engineers:</p><ul><li>From deterministic to probabilistic systems,</li><li>From code-only logic to mixed human–AI flows,</li><li>From building everything ourselves to <strong>strategically outsourcing cognition</strong>.</li></ul><p>The key is staying aware of the trade-offs:</p><ul><li>You’ll pay in cost, latency, and uncertainty,</li><li>But you gain in speed, versatility, and flexibility.</li></ul><p>Over time, you’ll develop a sense for the right balance, when to rely on the LLM’s flexibility, and when to replace it with something more deterministic and reliable. <strong>Striking that balance is part of the art of modern software design.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=862ab920e15b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/beyond-the-demo-real-world-problems-with-llm-api-implementation-862ab920e15b">Beyond the Demo: Real-World Problems with LLM API Implementation</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[2025: The Era of AI Agents : Breaking Free from the SaaS Mold]]></title>
            <link>https://medium.com/ewake-ai/2025-the-era-of-ai-agents-breaking-free-from-the-saas-mold-998a710bfd08?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/998a710bfd08</guid>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[site-reliability]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Omid Gosha]]></dc:creator>
            <pubDate>Wed, 21 May 2025 14:29:50 GMT</pubDate>
            <atom:updated>2025-05-21T14:37:56.925Z</atom:updated>
            <content:encoded><![CDATA[<h3>2025: The Era of AI Agents : Breaking Free from the SaaS Mold</h3><h3>1. Introduction: 2025 — The Year of Exploration for AI Agents</h3><p><strong>2025 is shaping up to be the year of exploration — not on Mars, but in the growing frontier of AI agents.</strong> Startups and giants alike are racing to define what these digital teammates can and should do. Expectations are sky-high: tireless collaborators, autonomous operators, and domain-specific experts wrapped in code. But as usual, the reality’s a little messier — a landscape of breakthrough moments mixed with frustrating constraints. Yet even as the ecosystem evolves, one aspect remains stubbornly stuck in the past: pricing.</p><p>Companies building and buying AI agents are still clinging to outdated SaaS models, per-user, per-seat, per-month, as if an agent were just another log-in. You’ve probably seen it yourself. Even industry leaders fall into this pattern, not out of ignorance but caution. After all, it’s hard to charge for something when we don’t have a shared mental model for what it <em>is</em>.</p><blockquote>Is it a tool? A service? A teammate? That’s the riddle and at the same time the opportunity behind the emerging concept of <strong>Teammate-as-a-Service</strong>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uBTDcmHcsRh06zXNh-x-gw.png" /></figure><h3>2. The Rise of AI Agents: Expectations vs. Reality</h3><p>We started with <em>workflows</em>. All across the world, AI teams were building chains of logic; tools that could follow steps, trigger actions, and automate routine processes. But today, as of May 2025, we’re no longer just talking about workflows. We’re talking about real agents — open-ended, self-guided digital entities that can chart their own paths toward a goal.</p><p>That’s a massive leap. The emergence of <strong>autonomous</strong>, <strong>goal-seeking </strong>agents marks a turning point in software, one where programs don’t just <em>do</em> things, they <em>figure out how</em> to do them. But as with any leap forward, expectations have started to outpace reality. Some companies are aiming for moonshot use cases — agents that can negotiate contracts, manage teams, or run entire operations. But in today’s practice, what is unfolding is just as exciting: agents aren’t here to replace humans. They’re here to <em>amplify</em> them. They take the friction out of work, handle the heavy coordination, and allow people to do what they do best — create, imagine, and lead. Real progress is happening, but it starts small. Smart delegation, not full automation. Augmentation, not replacement. And that’s not a limitation — it’s a foundation.</p><h3>3. The Paradigm Shift: From Software Tools to Dynamic Teammates</h3><p>Traditional software, whether SaaS platforms, dashboards, or desktop apps, has always been about providing <em>tools</em>. Powerful but static. Full of data, but waiting on a human operator to unlock their potential. Even seasoned engineers need hours, sometimes days, just to navigate to the depth of these tools, configure the right dashboards, and extract the insights they need.</p><blockquote>That’s the standard model: a tool, however powerful, still needs hands on the controls.</blockquote><p>But now, we’re stepping into the age of <strong>dynamic teammates</strong> — agents that act as <strong>operators</strong>, not just tools. Imagine asking a question in natural language — “Is anything abnormal in our production latency over the last 6 hours?” — and instead of diving into a dashboard, you simply delegate. Your agent investigates, surfaces the anomalies, contextualizes them across systems, and answers. No dashboards, no training, no switching tools. Just a teammate who knows where to look and what to do. That’s the shift. From being the pilot of a complex tool, to being the creative director supported by capable, tireless operators. It’s more than convenience — it’s a fundamental change in how we interact with technology.</p><h3>4. The Pricing Pitfall: SaaS Models Don’t Fit</h3><p>Here’s the truth everyone knows but few say out loud: <strong>you don’t price a teammate by the number of people they talk to.</strong> And yet, that’s exactly what the legacy SaaS model tries to do. Per-seat, per-user, per-month — these pricing models made sense when software was a static tool, locked behind dashboards and designed for individual operators. But an AI agent is not a tool, it’s a teammate.</p><blockquote>A real teammate sends a message to the channel the moment they have the answer. They don’t ask how many people will see it. In fact, the more, the better. Because value doesn’t come from <em>who</em> sees the insight — it comes from <em>what</em> the agent did to uncover it.</blockquote><p>Imagine a production incident is unfolding. Systems are red, alarms are going off. Your AI agent finds the root cause, posts the insight in Slack, and helps the team move fast. Are you really going to charge based on how many engineers viewed that message? Are you going to tell your client that this answer costs more because more people need it? That’s not just flawed, it’s absurd. No company hires a new teammate and says, “Only one person can talk to them.” That’s not how humans work. And it’s not how agents should either.</p><p>The true cost and the true value lie in the agent’s effort: <em>how much compute, time, and contextual depth it poured into solving the problem.</em> <br>That’s the human analogy. When you work with a brilliant operator, you value their time, their focus, their outcomes, not the number of people in the room when they speak. If we want AI agents to become true teammates, we need to let go of the seat-based mentality. The SaaS model isn’t just outdated — it’s a pitfall. And it’s holding the entire ecosystem back.</p><h3>5. Introducing Teammate-as-a-Service / Operator-as-a-Service</h3><p>It’s time to flip the script. The old model is broken, so let’s introduce a new one: <strong>Teammate-as-a-Service (TaaS)</strong> and <strong>Operator-as-a-Service (OaaS)</strong>. These aren’t just clever labels. They represent a pricing philosophy grounded in reality, in <em>value</em>. With TaaS and OaaS, you’re not paying for how many people access the output. You’re paying for the <em>time</em>, the <em>effort</em>, and the <em>depth of thinking</em> your agent provides, just like you would with a human teammate.</p><p>As previewed in the previous section, the core idea is simple: <strong>you pay for the minutes your AI teammate spends bringing value to your team</strong>. That’s it. Maybe those minutes involve diving into logs, correlating alerts, or generating customer insights; the complexity and context may vary. You might adjust for the intensity of the compute or the size of your tech stack, but the guiding principle stays the same: pricing should correlate to <em>work done</em>, not seats occupied.</p><p>It’s bold, sure — but not new. We’ve always paid people by the hour, the day, the output. Some days they warm up, others they’re running hot. Still, their presence and judgment <em>matter.</em> AI agents deserve the same framing.</p><p>Of course, this introduces a new challenge for us — the builders. How do we determine the cost per minute for an AI teammate? How do we translate compute cycles, context switching, and long-chain reasoning into a clean billing line item? Tough questions, yes. But exactly the ones we should be asking. Answering those means building trust, aligning incentives, and most importantly, it means shifting from treating agents like software licenses to the teammates they’re becoming.</p><h3>6. The Value Layer: What Businesses Actually Want from AI Agents</h3><p>What businesses really want isn’t more dashboards or flashy tech, it’s leverage. A way to extend and <strong>empower their teams</strong>. In 2023 and 2024, this began with co-pilots, lightweight assistants that helped individuals get answers faster, write code, and summarize content. Small boosts. But in 2025, with real agents, we’re entering a new tier of value: doing <em>more</em>, faster, with the <em>same headcount</em>.</p><p>That’s the promise of true agentic teammates. At <a href="http://ewake.ai/">Ewake.ai</a>, we commit to that promise by building your first production teammate. From first-time observability setups to scaling teams of seasoned engineers, <a href="http://ewake.ai/">ewake.ai</a> operates as an autonomous partner that grows with you.</p><p>It watches over your systems, flags what matters most, and works hand-in-hand with your engineers to move with speed and confidence. It doesn’t replace your team, it <em>amplifies</em> it. At least twice the productivity. Faster insight.</p><p>This is the real value layer — not licenses or logins, but <strong>capability unlocked</strong>. That’s what companies are buying.</p><h3>7. Real-World Implications: Redesigning Billing, UX, and Trust</h3><p>With this new model comes a new set of expectations, not just for pricing, but for how we build, deliver, and experience AI agents in the real world. Let’s break it down: <strong>billing, trust, and UX</strong>.</p><p>On billing, the shift is clear: companies should pay for value, not access. That might mean per minute, per hour, or even per day — depending on the intensity and duration of the task. Just like with human contractors or fractional hires, the model is flexible but anchored in contribution. It’s up to us — the builders — to expose clear, auditable signals that justify those charges, but without reducing the agent to a timesheet. What matters is <em>work delivered</em>.</p><blockquote>Trust is just as crucial. When you hire a human teammate, you don’t micromanage every step. You give them a problem, and you expect a result. That’s how we should treat AI agents, too. The value lies not in constant check-ins — “I’m fetching this,” “I’m thinking about that” — but in the ability to delegate, disconnect, and receive a complete, useful output. If the result misses the mark, you give feedback, just like you would to a human. But the default relationship is based on <strong>trust and ownership</strong>, not hand-holding.</blockquote><p>And that changes the <strong>user experience</strong> entirely. Dashboards made the user the operator — click here, filter this, find that. Agents reverse the role. The agent becomes the operator. It’s now <em>their</em> job to explore the landscape of your systems, tools, and data. You simply ask, and they go. You can give more detailed instructions when needed, but the navigation is no longer yours to manage. It’s invisible, fluid — and that’s the point.</p><p>This isn’t just a different way of charging for software. It’s a <strong>new paradigm for working with software,</strong> where the agent acts like a real teammate, and all the surrounding systems evolve to reflect that shift.</p><h3>8. The Road Ahead: A New Mental Model for AI Integration</h3><p>We’re not just building better tools, we’re redefining the very concept of work. The companies that thrive in this next chapter won’t be the ones who bolt agents onto old SaaS frameworks. They’ll be the ones who embrace a deeper shift: from Software as a Service to <strong>Teammate-as-a-Service</strong>.</p><p>This shift demands new pricing models, new UX thinking, and above all, <strong>new trust dynamics</strong>. It asks us to rethink how value is created, measured, and shared. And it opens the door to a world where scaling your operations doesn’t mean scaling your headcount — it means <strong>scaling intelligence</strong>.</p><p>That’s exactly the future we’re building at <a href="http://ewake.ai/"><strong>EWAKE.AI</strong></a>. We believe production reliability shouldn’t be a constant battle — it should bring <em>peace of mind</em>. Our mission is to provide your team with <strong>AI production teammates,</strong> agents that thrive in the day-to-day noise of maintenance, chaos, outages, deep investigations, and even the redesign of architecture decisions. Whether you’re scaling fast or running lean, <a href="http://ewake.ai/">EWAKE.AI</a> is designed to help you stay confident, informed, and always one step ahead.</p><p>This is just the beginning. The road ahead will be shaped by those bold enough to rethink the fundamentals. Let’s build teammates, not tools.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=998a710bfd08" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/2025-the-era-of-ai-agents-breaking-free-from-the-saas-mold-998a710bfd08">2025: The Era of AI Agents : Breaking Free from the SaaS Mold</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</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 Ewake.ai Newsletter!]]></title>
            <link>https://medium.com/ewake-ai/welcome-to-ewake-ai-newsletter-017eb13678d9?source=rss----8e46b9c07775---4</link>
            <guid isPermaLink="false">https://medium.com/p/017eb13678d9</guid>
            <dc:creator><![CDATA[Omid Gosha]]></dc:creator>
            <pubDate>Mon, 03 Feb 2025 21:37:19 GMT</pubDate>
            <atom:updated>2025-02-03T21:37:19.642Z</atom:updated>
            <content:encoded><![CDATA[<p>🔍 In a groundbreaking development for Site Reliability Engineering (SRE), Ewake.ai is pioneering the integration of AI teammates into operational workflows.</p><p>As highlighted in a recent article by CTO Omid Gosha, traditional SRE teams face overwhelming challenges, processing billions of log entries annually while juggling multiple monitoring tools and incident responses. Ewake.ai’s solution introduces an AI-powered SRE teammate that can simultaneously analyze massive volumes of data across various sources, from Datadog dashboards to Jira tickets, providing real-time insights and reducing incident response times from hours to minutes.</p><p>This innovative approach represents a significant shift from traditional automation tools to adaptive systems capable of understanding context, learning from interactions, and making informed decisions based on complex operational scenarios, potentially revolutionizing how SRE teams manage and maintain system reliability.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=017eb13678d9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ewake-ai/welcome-to-ewake-ai-newsletter-017eb13678d9">Welcome to Ewake.ai Newsletter!</a> was originally published in <a href="https://medium.com/ewake-ai">Ewake.ai</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>