Pruthvi Elavarthi

Your AI workload usually doesn’t fail because the model is “wrong”. It fails because the system around the model is fragile. Everyone is shipping LLM features like it’s a UI widget. Plug in one provider Add one vector DB Deploy in one region Call it “production” That is not production. That is a demo with a billing plan. Here’s the uncomfortable pattern I keep seeing. The pilot works perfectly. Then traffic grows. Latency jitters. One dependency hiccups for 90 seconds. And the whole product turns into a spinner. Not because the model forgot English. Because your architecture has no place for failure to go. The most common real world failure is boring. The embedding service rate limits. Your vector search slows down. The LLM times out. Now your app retries. Retries amplify load. Load amplifies latency. Latency amplifies retries. Congratulations, you just built a failure flywheel. And the worst part is what teams do next. They add more prompts. They tweak temperature. They debate which model is smarter. None of that fixes an AI system that can’t degrade gracefully. Production AI is an outage game. It needs cacheable answers, fallbacks, and a path that still returns something useful when parts of the stack are on fire. Because your users do not care that your vector DB had a bad day. They care that your product stopped respecting their time. If your AI feature cannot return a safe, fast “good enough” response when one layer fails, you didn’t build a platform. You built a dependency chain. So pick your philosophy. Do you want impressive demos, or boring reliability. What is the first component in your AI stack that you are willing to let fail without the user noticing? #AIEngineering #LLMOps #ReliabilityEngineering #PlatformEngineering #ProductionSystems #Observability #rajansharma

5

2 Comments

From Kernel to User Mode: The Ring 3 🦀Lets Run GTA 5 in JC-OS 😎 #RustLang #OsDev #SystemsProgramming #X86_64 #JCOS #TheRustEagle

2

Cloudflare has made a significant shift in default settings for AI crawlers, moving from "index freely" to "block → license → pay." In this new setup, approximately 20% of the web, particularly content behind Cloudflare, is now shielded from unauthorized model training. Access is redirected through a "Pay Per Crawl" marketplace. From my perspective, this move represents a strategic maneuver, positioning Cloudflare at a crucial junction between AI labs and valuable data streams. While the previous unregulated scraping approach had its advantages, sustainability was always a concern. A structured framework is essential to safeguard content creators while fostering responsible AI advancements. The landscape of the open web is evolving from being merely searchable to becoming licensable, with Cloudflare taking a proactive stance in this transformation. Will their product strategy work? This remains to be seen. For further insight please refer to the article on Business Insider. https://lnkd.in/dmHvnMWQ #Cloudflare #GenAI #DataEconomy #ContentProtection #ProductStrategy

10

Indian telecom operators need to recognize the significance of this move and the critical role Internet Exchange Points (IXPs) play in efficient content delivery and traffic exchange.

3

SR-MPLS vs SRv6 MSD — Why Segment Depth Scales Differently As Segment Routing adoption expands across large service provider backbones and cloud-scale fabrics, Maximum SID Depth (MSD) is becoming a key design parameter — especially in environments using hierarchical TE, binding SID indirection, service overlays, and slicing constructs. At a high level, MSD simply indicates how many segments a node can process or impose. But in practice, MSD has very different architectural implications in SR-MPLS versus SRv6. In SR-MPLS, segments are encoded as a label stack at the packet front. Each hop processes labels sequentially, requiring parser traversal, PHV storage, and modification operations (pop/swap/push). As stack depth grows, multiple pipeline resources are stressed simultaneously — parser extraction windows, header vector space, modification stages, and ECMP visibility. This makes SR-MPLS MSD closely tied to forwarding silicon limits, and deep stacks can introduce ECMP polarization or even recirculation in extreme cases. In contrast, SRv6 uses a pointer-based forwarding model where segments reside inside an IPv6 Segment Routing Header and a segment pointer identifies the active segment. Forwarding typically advances the pointer rather than removing headers. Because the full segment list does not need to be materialized into pipeline metadata, parser and modification complexity remain relatively stable as segment depth grows. This leads to a useful design perspective: ➡️ SR-MPLS scaling is primarily parser- and pipeline-constrained ➡️ SRv6 scaling is primarily encapsulation- and MTU-constrained Operationally, this difference manifests in several ways. Deep SR-MPLS stacks can obscure payload headers from ECMP hash engines, requiring entropy labels or programmable hashing techniques. SRv6, however, retains IPv6 encapsulation, allowing consistent load balancing independent of segment list length. Similarly, PHV resource pressure is often a hidden SR-MPLS scaling factor, while SRv6 depth typically has minimal metadata impact. As a result, many networks are adopting hybrid SR architectures — leveraging SR-MPLS for efficient core transport and SRv6 for flexible service programmability — balancing efficiency with expressiveness. The key takeaway: while MSD appears as a simple numeric capability, its real meaning depends on the underlying forwarding architecture. Understanding this distinction helps operators design segment routing policies that align with both silicon constraints and transport efficiency goals. Curious to hear how others are balancing SR-MPLS and SRv6 MSD considerations in large-scale deployments.

62

This is true. I see Telco would need to reshape their Observability Framework to collect their own sources of data from their network to train their own models not to buy AI solutions, but create AI platform instead and build their own models on top. I do see they are jumping to multi Agents frameworks without understanding that the most important to have reliable outcome with most cost effective is to create a foundation for AI, not all about the Agents.

11

Memory management is one of the biggest challenges AI engineers face today. LLMs are stateless by design, which means every intelligent agent needs a robust memory layer to truly perform in real-world environments. With the introduction of the Redis Agent Memory Server, Redis is tackling this challenge head-on. The open-source solution brings a two-tier memory architecture (working + long-term memory), semantic retrieval, metadata filtering, and asynchronous memory extraction — all built for production scale and speed. It’s a powerful example of how Redis continues to evolve beyond caching into a core infrastructure layer for AI-native applications. If you're building AI agents and thinking about context engineering, persistent memory, and intelligent retrieval, you should explore this! Thank you to Andrew Brookins, Principal Applied AI Engineer, and Raphael De Lio, Developer Advocate at Redis, for sharing this article with us! ➡️ Read the full article on our magazine: https://lnkd.in/db3-fhZT #AI #Redis #AgenticAI #LLMs #DeveloperTools

5

🧩 How do these black-and-white squares make payments, open websites, or connect to Wi-Fi? We see QR codes everywhere, from scanning menus 🍽️ to paying bills 💸 to logging into Wi-Fi 📶. The little we are concerned about is how these tiny squares actually carry and store information. Because behind those random-looking boxes lies a brilliant mix of image processing, encoding algorithms, and error correction, all happening in milliseconds⚡ 🔍 What’s really inside a QR code? A QR (Quick Response) Code isn’t just an image; it’s a data matrix. Each small black or white square (called a module) represents a bit - 0 or 1; arranged in a pattern that encodes real information. That data can be: ✅ Text ✅ URLs ✅ Payment IDs ✅ Wi-Fi credentials ✅ Even small binary data or images Depending on its version, a single QR code can hold up to 4,296 alphanumeric characters! ⚙️ How it actually stores information 1️⃣ Encoding The original data (like a UPI link or website URL) is converted into binary using one of several encoding schemes — numeric, alphanumeric, byte, or Kanji (for Japanese text). 2️⃣ Error Correction (Reed–Solomon) QR codes use Reed–Solomon error correction, a mathematical algorithm that allows up to 30% of the code to be damaged (folds, scratches, glare) and still be readable. 3️⃣ Module Mapping The binary and error-correction bits are arranged in precise positions inside the grid, surrounded by key structures: ➡️ Finder patterns (those 3 large corner boxes — used for orientation) ➡️Alignment patterns (to correct distortion) ➡️Timing patterns (to identify rows/columns) 📱 What happens when you scan it? When your phone camera or Google Lens scans a QR code: 1️⃣ The app detects the finder patterns. 2️⃣ It adjusts for angle, rotation, and lighting using computer vision. 3️⃣ It samples each tiny module (black = 1, white = 0). 4️⃣ The Reed–Solomon algorithm fixes any corrupted data. 5️⃣ Finally, it decodes the binary data into a readable action, like opening a URL, triggering a payment, or connecting to Wi-Fi. …and remember, barcodes were developed much earlier and dominated retail and logistics. So how did QR codes evolve to outperform them and become the modern standard? 🔍 Why QR codes beat barcodes Traditional barcodes store data in one dimension, horizontally, using black-and-white lines. They require laser scanners that detect reflected light as the beam sweeps across. QR codes, on the other hand, are two-dimensional. They store data both horizontally and vertically, allowing hundreds of times more information and no need for lasers. Your smartphone camera (or any image sensor) captures the entire pattern at once. Then, built-in image processing algorithms decode the data instantly, making QR codes faster, cheaper, and far more versatile. #Technology #Engineering #Innovation #EmbeddedSystems #TechExplained #EngineeringDesign #TechFacts #DidYouKnow

12

Dharmasthala Files: Can Technology Offer a Faster, More Efficient Solution Than Excavation? The alleged tragedy of 400-500 deaths is deeply unsettling. If true, it shakes our trust in safety—making us question how we travel and protect our loved ones. While the SIT’s excavation efforts are commendable, the process is painstakingly slow and may not cover all areas thoroughly. There’s a better way. Ground-Penetrating Radar (GPR) and Electrical Resistivity Tomography (ERT) are proven geophysical methods used in archaeology, forensics, and utility detection. These technologies can: ✔ Scan large areas non-invasively ✔ Detect skeletal remains even 6-8 feet underground ✔ Generate high-resolution subsurface imaging for targeted excavation Why rely solely on manual digging when science can guide efforts more efficiently? Authorities should integrate these tools to accelerate investigations. What do you think? Should forensic tech play a bigger role in such cases? #DharmasthalaFiles #GPR

11

I’ve been experimenting with a binary classification model on a highly imbalanced real-world dataset and encountered an interesting issue related to changes in label distribution during inference. I’d like to share the details and gather input from the ML community. I am currently working on a binary classification problem using a Neural Network. Main Main components in Network with the following architecture: Unidirectional LSTM + Self-Attention + Feed-Forward Network Final layer: Dense (Sigmoid activation) Custom loss function developed to handle significant class imbalance Dataset Characteristics: Real-world data in the order of gigabytes Highly imbalanced — approximately 10% negative (True) and 90% positive (True) Validation split maintains a similar ratio Model Performance (Training & Validation): FNR ≈ FPR ≈ 5% Sensitivity@95%Specificity ≈ 0.87 Specificity@95%Sensitivity ≈ 0.84 (train) and 0.88 (validation) Observed Behavior: During inference, when the dataset label distribution matches the training ratio (≈10% negatives), performance is consistent with training/validation results. However, when the inference dataset exhibits a different label distribution (e.g., 18% negatives / 82% positives), the results deviate significantly: FNR increases to ~9–10% FPR increases to ~18–20% The shift is consistent across thresholds (e.g., at 0.4 threshold FNR ≈ 9–10%, FPR ≈ 18–20%; reversing around 0.6). All datasets originate from the same environment, with the only variable being the label ratio. Query: How can we effectively handle large-scale imbalanced datasets and ensure the model remains robust to shifts in label distribution during inference? I would appreciate insights on methods such as recalibration techniques, threshold optimization, logit adjustment, or alternative post-processing strategies that have worked in similar scenarios. #MachineLearning #DeepLearning #AICommunity #ImbalancedData #ModelEvaluation

6

1 Comment