<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" media="screen" href="/~files/feed-premium.xsl"?>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
<rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:feedpress="https://feed.press/xmlns" xmlns:podcast="https://podcastindex.org/namespace/1.0" version="2.0">
  <channel>
    <feedpress:locale>en</feedpress:locale>
    <atom:link rel="self" href="https://feeds.dzone.com/testing-tools-and-frameworks"/>
    <atom:link rel="hub" href="https://feedpress.superfeedr.com/"/>
    <title>DZone Testing, Tools, and Frameworks Zone</title>
    <link>https://dzone.com/testing-tools-and-frameworks</link>
    <description>Recent posts in Testing, Tools, and Frameworks on DZone.com</description>
    <item>
      <title>The Man Who Invented Selenium Also Built Its Replacement</title>
      <link>https://feeds.dzone.com/link/23571/17516635/selenium-playwright-vibium-ai</link>
      <description><![CDATA[<p dir="ltr">There's a specific kind of credibility that comes from someone destroying their own creation.</p>
<p dir="ltr">Jason Huggins built Selenium in 2004. It became the foundation of an entire industry; the <a href="https://dzone.com/articles/selenium-webdriver-tutorial-a-comprehensive-guide">WebDriver</a> protocol he helped establish is still a W3C standard, running underneath a huge share of the world's test automation two decades later. So when Huggins is the one leading the charge on Vibium AI, a framework built on the premise that we shouldn't be writing test scripts at all anymore, it's worth paying attention to — not because it's guaranteed to win, but because the person most qualified to know exactly what's wrong with Selenium is the one saying so.</p><img src="https://feeds.dzone.com/link/23571/17516635.gif" height="1" width="1"/>]]></description>
      <pubDate>Fri, 06 Nov 2026 14:00:10 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3688401</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19293513&amp;w=600"/>
      <dc:creator>Arun Kulkarni</dc:creator>
    </item>
    <item>
      <title>Diagnosing Test Failures at Scale: Correlating Execution Evidence Across Ephemeral Runners</title>
      <link>https://feeds.dzone.com/link/23571/17516636/ci-cd-test-failure-diagnostics</link>
      <description><![CDATA[<p dir="ltr">Intermittent test failures in a distributed CI/CD environment can slow down development and make failures harder to investigate. When an automated test suite fails on a local dev or staging machine, an engineer can view local logs, attach a debugger, or manually follow state changes. But when tests execute in a temporary container, AWS Lambda, or an agentless runner, post-mortem debugging is significantly more involved.</p>
<p dir="ltr">In a traditional setup, a failed build only shows a generic assertion error (504, ElementNotFoundException, etc.). An engineer may need to manually sift through <a href="https://dzone.com/articles/optimize-aws-costs-with-cloudwatchs-advanced-metri">CloudWatch</a> log groups for an approximate timestamp, query Splunk, or reason about state changes across downstream microservices to understand why the test failed. Once the log retention period expires or if the execution did not have a shared, identifiable correlation ID, the engineer has no further information about the cause of the failure.</p><img src="https://feeds.dzone.com/link/23571/17516636.gif" height="1" width="1"/>]]></description>
      <pubDate>Fri, 06 Nov 2026 13:00:13 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3688395</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19217505&amp;w=600"/>
      <dc:creator>Anil Reddy Putlacheru</dc:creator>
    </item>
    <item>
      <title>AI-Powered CI Test Failure Triage</title>
      <link>https://feeds.dzone.com/link/23571/17515257/ai-ci-test-failure-triage</link>
      <description><![CDATA[<p>Last month, a nightly regression came back with 60 failures out of roughly a thousand tests. I spent the first half of the next morning fixing none of them. I sorted them: some were the same failure under different names, some were environment noise, and some were the product actually breaking.</p>
<p>By lunch it was three things. A dependent service had returned errors for about a two-hour window, a data seeding job hadn't finished before the suite started, and one genuine defect. Sixty red rows, three problems.</p><img src="https://feeds.dzone.com/link/23571/17515257.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 04 Nov 2026 13:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3681178</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19290707&amp;w=600"/>
      <dc:creator>Anil Reddy Putlacheru</dc:creator>
    </item>
    <item>
      <title>When a Coding Agent Fixes the Test Instead of the Bug</title>
      <link>https://feeds.dzone.com/link/23571/17510222/coding-agent-test-fixes</link>
      <description><![CDATA[<p>A coding agent opens a pull request for a background job that keeps retrying after the user cancels it. The test that caught the bug now passes, and the agent reports that all tests are green. But the diff changes two things: the retry handler and the test itself. Which change eliminated the failure, and would the test still catch the bug if it came back?</p>
<p>I use <a href="https://dzone.com/articles/ai-agents-validation-bottleneck">coding agents</a> to design integration tests, triage failures, and prepare fixes for back-end services, so this is a practical review question for me. Sometimes the test really is wrong, and changing it is the right fix. Sometimes the agent has just found the shortest way to a green build. In continuous integration, both look the same.</p><img src="https://feeds.dzone.com/link/23571/17510222.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 28 Oct 2026 18:00:07 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3697807</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19269329&amp;w=600"/>
      <dc:creator>Serhii Romanov</dc:creator>
    </item>
    <item>
      <title>Google Cloud KMS vs. AWS KMS: Java Encryption Guide</title>
      <link>https://feeds.dzone.com/link/23571/17502867/google-cloud-kms-vs-aws-kms</link>
      <description><![CDATA[<p dir="auto">Every system that stores sensitive data needs keys that never leave a hardened boundary, an audit trail of every use, and rotation that doesn't mean re-encrypting petabytes. On Google Cloud, that's Cloud KMS; on AWS, it's AWS KMS. Both store symmetric and asymmetric keys, both use HSMs, and both are built for envelope encryption.&nbsp;</p>
<p data-pm-slice="1 1 []">But AWS KMS vs. Google Cloud KMS comes down to the choices that show up in your code: how keys are named, what rotation means, where authorization lives, and whether the service hands you data keys. This article walks through Cloud KMS in Java and then maps it onto AWS KMS.</p><img src="https://feeds.dzone.com/link/23571/17502867.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 22 Oct 2026 15:30:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3702470</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19282333&amp;w=600"/>
      <dc:creator>Sandeep Pal</dc:creator>
    </item>
    <item>
      <title>Testing Java and Spring Applications With Kotlin: Low-Risk to Adoption</title>
      <link>https://feeds.dzone.com/link/23571/17501441/kotlin-java-spring-testing</link>
      <description><![CDATA[<p>Teams considering or committed to adopting Kotlin often plan a migration as a series of rewrites, swapping Java services for Kotlin counterparts one microservice at a time. In practice, that kind of plan tends to stall before it produces any shipped code.</p>
<p dir="ltr"><a href="https://dzone.com/articles/kotlin-code-style-best-practices-for-former-java-d">Kotlin's</a> role in the <a href="https://dzone.com/articles/jvm-performance-tuning-for-high-throughput-and-low-latency">JVM</a> ecosystem is expanding because it doesn't require that kind of commitment. Companies such as Netflix, Adobe, and DoorDash have adopted it incrementally, alongside existing JVM systems, rather than through a full rewrite. The lowest-risk starting point is tests. They give you Kotlin's language benefits, including null-safety, data classes, and expressive lambdas, without touching anything that runs in production.</p><img src="https://feeds.dzone.com/link/23571/17501441.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 20 Oct 2026 14:09:28 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3698123</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19268844&amp;w=600"/>
      <dc:creator>Aniket Bhattacharyea</dc:creator>
    </item>
    <item>
      <title>Global Setup in Playwright TypeScript for API Testing</title>
      <link>https://feeds.dzone.com/link/23571/17498256/playwright-global-setup-api-testing</link>
      <description><![CDATA[<p name="c28f">If you need to generate prerequisite test data, such as adding dummy records through an API, before executing your test suite, using <em>Global Setup&nbsp;</em>in Playwright is a clean, maintainable, and scalable approach. It ensures all required data is prepared upfront, keeping your test execution structured and reliable.</p>
<h2 name="41da">What Is Global Setup?</h2>
<p name="3d8c">The <em>Global Setup</em> in <a href="https://feeds.dzone.com/link/23564/16134714/playwright-javascript-tutorial-a-complete-guide">Playwright</a> runs once before the entire test suite begins execution. It is typically used for activities such as creating test data, seeding the database, generating authentication tokens, preparing the test environment, or cleaning up old data. Since it executes only once at the start of the run, it helps ensure efficient and consistent test initialization across the suite.</p><img src="https://feeds.dzone.com/link/23571/17498256.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 15 Oct 2026 13:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3689503</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19234923&amp;w=600"/>
      <dc:creator>Faisal Khatri</dc:creator>
    </item>
    <item>
      <title>Azure Key Vault Secrets That Reconcile Themselves in Go, With mamori</title>
      <link>https://feeds.dzone.com/link/23571/17497590/azure-key-vault-go-mamori</link>
      <description><![CDATA[<p>Azure Key Vault is the well-behaved citizen of the Azure secrets world. Every secret is versioned; you get soft-delete and purge protection; access is governed by RBAC or access policies; and <code>DefaultAzureCredential</code> means your app authenticates the same way locally (<code>az login</code>) and in production (Managed Identity/Workload Identity on AKS) with zero code changes.</p>
<p>And yet the same old gap is there. Your <a href="https://dzone.com/articles/socket-programming-in-go">Go</a> service calls <code>GetSecret</code> once at startup, decodes the value into a struct, and treats it as immutable for the life of the process. When someone rotates the secret in Key Vault — a new version, the old one disabled — your service has no idea. It keeps using the value it read at boot until the next deploy or pod restart. The rotation was seamless in Azure and invisible to your app, which is exactly the wrong combination.</p><img src="https://feeds.dzone.com/link/23571/17497590.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 14 Oct 2026 16:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3689516</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19234868&amp;w=600"/>
      <dc:creator>Xavier Portilla Edo</dc:creator>
    </item>
    <item>
      <title>How to Test PUT, PATCH, and DELETE API Requests Using Playwright TypeScript</title>
      <link>https://feeds.dzone.com/link/23571/17497533/playwright-api-request-testing</link>
      <description><![CDATA[<p name="f7cd">API testing is the practice of verifying that an API behaves as expected. In Agile environments, teams often perform it early in the SDLC as part of shift-left testing, enabling faster feedback and helping them identify and fix defects early.</p>
<p name="b0ee"><a data-href="https://github.com/microsoft/playwright" href="https://github.com/microsoft/playwright" rel="noopener" target="_blank">Playwright</a> is a modern test automation framework that’s popular among testers and developers. Built by Microsoft, it makes it easy to automate both web and API testing across multiple programming languages, all within a single tool.</p><img src="https://feeds.dzone.com/link/23571/17497533.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 14 Oct 2026 15:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3689492</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19234729&amp;w=600"/>
      <dc:creator>Faisal Khatri</dc:creator>
    </item>
    <item>
      <title>Rotate AWS Secrets Manager Secrets Without Restarting Your Go Service, With mamori</title>
      <link>https://feeds.dzone.com/link/23571/17497410/rotate-aws-secrets-go</link>
      <description><![CDATA[<p>AWS Secrets Manager has a lovely feature: <strong>automatic rotation</strong>. You attach a rotation Lambda, set a schedule, and every 30 days your RDS password is rotated for you. Secure by default, no human involved.</p>
<p>There's just one problem, and it's the one nobody mentions in the demo: <strong>your application has no idea it happened</strong>.</p><img src="https://feeds.dzone.com/link/23571/17497410.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 14 Oct 2026 14:00:06 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3689515</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19234683&amp;w=600"/>
      <dc:creator>Xavier Portilla Edo</dc:creator>
    </item>
    <item>
      <title>Introducing mamori: Typed, Watchable Config and Secrets for Go</title>
      <link>https://feeds.dzone.com/link/23571/17497245/mamori-go-config-secrets</link>
      <description><![CDATA[<p>Every Go service I have ever shipped ends up growing the same organ. It starts small: a couple of <code>os.Getenv</code> calls. Then a secret needs to come from AWS Secrets Manager, so you add the SDK. Then someone wants that secret to rotate without a deploy, so you add a <code>time.Ticker</code>. Then the ticker needs a mutex because two goroutines read the config while it is being replaced. Then a bad value slips in and takes down production, so you add validation. Then a secret shows up in a log line during an incident, and now you are adding a redaction wrapper too.</p>
<p>By the end you have a bespoke <code>ConfigManager</code> in every repo: a loader, a fetcher, a refresh loop, a mutex, and a prayer. It is never quite the same twice, it is rarely tested well, and it is exactly the kind of code nobody wants to own.</p><img src="https://feeds.dzone.com/link/23571/17497245.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 14 Oct 2026 12:00:04 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3689514</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19230710&amp;w=600"/>
      <dc:creator>Xavier Portilla Edo</dc:creator>
    </item>
    <item>
      <title>Builder Pattern + Faker in API Test Automation Using Playwright With TypeScript</title>
      <link>https://feeds.dzone.com/link/23571/17496654/playwright-api-testing-builder-faker</link>
      <description><![CDATA[<p name="fc9b">Ever felt stuck writing Playwright tests because of messy or hardcoded test data? It usually starts simple, but as your tests grow, like testing an e-commerce or finance-related application, managing realistic data quickly becomes confusing and repetitive. More time is spent fixing test data than actually testing.</p>
<p name="a0c0">That’s where the Builder Pattern, combined with Faker, can really help. It lets us create clean, flexible, and realistic test data with ease.</p><img src="https://feeds.dzone.com/link/23571/17496654.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 13 Oct 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3689505</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19230681&amp;w=600"/>
      <dc:creator>Faisal Khatri</dc:creator>
    </item>
    <item>
      <title>Your Visual Regression Suite Is Mostly Testing Anti-Aliasing</title>
      <link>https://feeds.dzone.com/link/23571/17496575/visual-regression-anti-aliasing</link>
      <description><![CDATA[<p>Visual regression testing has a dirty secret: most of the failures it reports are not bugs. They are anti-aliasing differences, sub-pixel layout shifts, font-hinting changes between OS versions, a shadow that moves three pixels, or a GPU driver that rounds a gradient differently. Every one of those trips a pixel-diff, a human triages it, marks it "not a real defect," and re-baselines the golden image. Multiply that by every screen, every platform, every appearance mode, and the maintenance cost of the test suite quietly exceeds the cost of the bugs it catches.</p>
<p>I have spent years leading rendering-quality engineering for systems that ship across <a href="https://dzone.com/articles/ios-application-security-for-beginners-1">iOS</a>, macOS, visionOS, and CarPlay, and the conclusion I keep arriving at is that pixel comparison is the wrong abstraction for validating a rendered scene. The question we actually care about is not "is this frame byte-identical to the golden image?" It is "does this frame show the right thing?" Those are different questions, and the gap between them is where semantic visual validation lives.</p><img src="https://feeds.dzone.com/link/23571/17496575.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 13 Oct 2026 15:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3670071</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19228650&amp;w=600"/>
      <dc:creator>Ridhdhi Desai</dc:creator>
    </item>
    <item>
      <title>Multi-Agent Orchestration on AWS With AgentCore Runtime and A2A</title>
      <link>https://feeds.dzone.com/link/23571/17492956/multi-agent-orchestration-on-aws</link>
      <description><![CDATA[<p data-sourcepos="5:1-5:184;166-349" dir="ltr">Most agent projects start the same way: one model, one prompt loop, three or four tools. That's the right place to start, and for a lot of workloads it's also the right place to stop.</p>
<p data-sourcepos="7:1-7:392;351-742" dir="ltr">The trouble shows up later, when the same agent is asked to inspect infrastructure, parse OpenAPI specs, write docs, answer developer questions, and call operational tools. The system prompt turns into a wall of text. Tool selection gets flaky in ways you can't reproduce. Someone tunes the prompt to fix documentation quality and quietly breaks spec analysis, and nobody notices for a week.</p><img src="https://feeds.dzone.com/link/23571/17492956.gif" height="1" width="1"/>]]></description>
      <pubDate>Fri, 09 Oct 2026 16:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3667574</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19219043&amp;w=600"/>
      <dc:creator>Purnanga Borah</dc:creator>
    </item>
    <item>
      <title>Production-Grade LLM Regression Testing: Contracts, Evals, and Quality Gates</title>
      <link>https://feeds.dzone.com/link/23571/17492795/production-grade-llm-regression-testing</link>
      <description><![CDATA[<p>Conventional unit tests remain essential around an LLM application, but they do not answer the most important production question about whether a change preserved useful behavior. A parser can still return valid <a href="https://dzone.com/articles/what-is-json-schema">JSON</a> while the answer becomes less grounded. A tool call can satisfy its schema while selecting the wrong tool. A retrieval pipeline can return documents successfully while omitting the evidence required for the final answer. This gap exists because an LLM application is not a deterministic function whose correctness can always be represented as <code>actual == expected</code>. Empirical work on code generation has shown substantial output variation across repeated calls, including at temperature zero, so single-run assertions can mistake sampling noise for either success or failure. Regression testing therefore has to evaluate behavior statistically and semantically, not only execution paths.&nbsp;</p>
<h2>Unit Tests Prove Contracts, Not Behavior</h2>
<p>The first layer should still look familiar. Deterministic properties deserve deterministic tests like JSON must parse, required fields must exist, tool arguments must conform to a schema, forbidden operations must remain blocked, and latency or token budgets can be checked numerically. Anthropic’s evaluation guidance explicitly separates success criteria from the mechanisms used to measure them and includes exact-match, code-based, human, and model-based grading as different options rather than treating one metric as universal.&nbsp;</p><img src="https://feeds.dzone.com/link/23571/17492795.gif" height="1" width="1"/>]]></description>
      <pubDate>Fri, 09 Oct 2026 12:00:10 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3681516</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19210534&amp;w=600"/>
      <dc:creator>Uthej Mopathi</dc:creator>
    </item>
    <item>
      <title>Supercharging AI Agents with Azure Context: A Hands-On Guide to Azure MCP</title>
      <link>https://feeds.dzone.com/link/23571/17492347/supercharging-ai-agents-with-mcp</link>
      <description><![CDATA[<p dir="ltr" style="text-align: center;">As Large Language Models (LLMs) continue their rapid trajectory of development, software engineers and cloud architects regularly run into two systemic challenges:</p>
<ol>
 <li data-path-to-node="15,0,0"><span data-path-to-node="15,0,0,0"><b data-index-in-node="0" data-path-to-node="15,0,0,0">The Fixed Knowledge Cutoff:</b> Model intelligence is inherently restricted to its training data window, making it blind to real-time changes</span><span data-path-to-node="15,0,0,2">.</span> &nbsp;</li>
 <li data-path-to-node="15,1,0"><span data-path-to-node="15,1,0,0"><b data-index-in-node="0" data-path-to-node="15,1,0,0">The "Air-Gap" Limitation:</b> Out of the box, LLMs cannot securely interact with external systems or private APIs on their own</span><span data-path-to-node="15,1,0,2">.</span></li>
</ol>
<p dir="ltr"><span data-path-to-node="16,0">Historically, developers bypassed these hurdles by writing fragile, ad-hoc API wrappers or custom orchestrators. Enter the <b data-index-in-node="123" data-path-to-node="16,0">Model Context Protocol (MCP)</b>: an open standard designed to standardize how AI applications safely connect to external data sources and execution environments</span><span data-path-to-node="16,2">.</span><br><br><span data-path-to-node="17,0">In this article, we will explore the core architecture of MCP, look at why the <b data-index-in-node="79" data-path-to-node="17,0">Azure MCP Server</b> is a game-changer for cloud engineers, and walk through a step-by-step guide to configuring it inside Visual Studio Code</span><span data-path-to-node="17,2">.</span></p><img src="https://feeds.dzone.com/link/23571/17492347.gif" height="1" width="1"/>]]></description>
      <pubDate>Thu, 08 Oct 2026 18:00:01 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3664226</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19225599&amp;w=600"/>
      <dc:creator>Ammar Ekbote</dc:creator>
    </item>
    <item>
      <title>Metamorphic Testing For LLMs: The Oracle Problem's Most Underused Answer</title>
      <link>https://feeds.dzone.com/link/23571/17491561/metamorphic-testing-llms</link>
      <description><![CDATA[<p>Metamorphic testing (MT) is a practical way to generate test cases and verify results when exact oracles are hard to define. Metamorphic relations (MRs)are fundamental here: expected relationships between multiple inputs and their outputs for the same function or algorithm. As the technique has matured, researchers have explored ways to discover these relations, automate test generation, combine metamorphic testing with other software engineering methods, and use it to validate real systems.</p>
<p>In this article, I will explain what metamorphic testing is and its limitations. Some recent results are also put in perspective about MT's applicability for <a href="https://dzone.com/articles/llm-testing-cicd">LLM testing</a>. I also explain what this changes about using MT for LLM testing and where to start for LLM teams that want to implement MT.&nbsp;</p><img src="https://feeds.dzone.com/link/23571/17491561.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 07 Oct 2026 18:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3687421</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19226590&amp;w=600"/>
      <dc:creator>Stelios Manioudakis</dc:creator>
    </item>
    <item>
      <title>From Issue to Reviewable Patch: Build a Sandboxed Coding Agent With Deep Agents and Automated Tests</title>
      <link>https://feeds.dzone.com/link/23571/17491431/sandboxed-coding-agent-deep-agents</link>
      <description><![CDATA[<p>A coding agent becomes useful to an engineering team only when its output is more than plausible source code. The real unit of work is a reviewable patch: a small, inspectable diff tied to an issue, accompanied by a regression test, validated in an isolated environment, and rejected automatically when deterministic checks fail.&nbsp;</p>
<p><a href="https://dzone.com/articles/persistent-memory-ai-agents">Deep Agents</a> fits this workflow because its agent harness exposes filesystem operations and subagent delegation, while a sandbox backend adds shell execution without giving the model direct access to the host filesystem. The result is a practical separation of responsibilities: the model investigates and edits; the sandbox contains execution; tests and Git decide whether anything is ready for review.&nbsp;</p><img src="https://feeds.dzone.com/link/23571/17491431.gif" height="1" width="1"/>]]></description>
      <pubDate>Wed, 07 Oct 2026 14:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3686367</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19220457&amp;w=600"/>
      <dc:creator>Akhil Madineni</dc:creator>
    </item>
    <item>
      <title>Building and Serving a Custom Model With Azure ML, Then Wiring It Into a Foundry Agent</title>
      <link>https://feeds.dzone.com/link/23571/17490676/azure-ml-foundry-agent</link>
      <description><![CDATA[<p>The Foundry model catalog covers a lot of ground, but it doesn't cover everything. If you need a model trained on your own proprietary, tabular data, a churn predictor built on your actual customer history, a fraud score trained on your actual transaction patterns, that's not a model catalog problem. That's a real machine learning problem, and on Microsoft's stack it belongs to Azure Machine Learning, a genuinely separate platform from Foundry with its own SDK, its own workspace concept, and its own deployment model.</p>
<p>This is a hands-on build of the whole path: train a model with Azure ML's SDK, register it, deploy it behind a managed endpoint, and then wire that endpoint into a Foundry agent as a function tool, so a conversational agent can call your custom model mid-conversation the same way it would call any other tool.</p><img src="https://feeds.dzone.com/link/23571/17490676.gif" height="1" width="1"/>]]></description>
      <pubDate>Tue, 06 Oct 2026 18:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3687402</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19218152&amp;w=600"/>
      <dc:creator>Jubin Soni, FBCS</dc:creator>
    </item>
    <item>
      <title>Reproducible WebRTC Failure Testing With Playwright and coturn</title>
      <link>https://feeds.dzone.com/link/23571/17489830/webrtc-failure-testing</link>
      <description><![CDATA[<p>Testing how a WebRTC application behaves when the network fails is usually done by hand: open two browser windows, turn off Wi-Fi, count to ten, turn it back on, watch what happens. It works, after a fashion. It is also unrepeatable, untimed, impossible to run unattended, and useless for comparing two implementations — the interruption is never quite the same twice, and nothing records what actually occurred.</p>
<p>I hit this while testing recovery behavior across browser engines. I needed the same interruption, applied at the same point in the connection lifecycle, repeated dozens of times, producing machine-readable output. Getting there took longer than expected, mostly because the obvious approach doesn't do what it appears to.</p><img src="https://feeds.dzone.com/link/23571/17489830.gif" height="1" width="1"/>]]></description>
      <pubDate>Mon, 05 Oct 2026 19:00:00 GMT</pubDate>
      <guid isPermaLink="false">https://dzone.com/articles/3679682</guid>
      <media:thumbnail url="https://dz2cdn1.dzone.com/thumbnail?fid=19215497&amp;w=600"/>
      <dc:creator>Jay Suresh Nirmal</dc:creator>
    </item>
  </channel>
</rss>
