# Grab Tech

Grab's Engineering team solves critical transportation challenges and makes transport freedom a reality for 620 million people in Southeast Asia.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## App stability at scale with a layered defense

DevFeed: [App stability at scale with a layered defense](<https://devfeed.tech/articles/app-stability-at-scale-with-a-layered-defense-91299.md>)

Original publisher: [Read original article](<https://engineering.grab.com/app-stability-at-scale-with-a-layered-defense>)

Author: Nguyen Van Minh

Published: 2026-10-21T00:23:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [mobile-app-performance](<https://devfeed.tech/topics/mobile-app-performance.md>), [mobile devops](<https://devfeed.tech/topics/mobile-devops.md>), [Crashlytics](<https://devfeed.tech/topics/crashlytics.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Android](<https://devfeed.tech/topics/android.md>), [Firebase](<https://devfeed.tech/topics/firebase.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [appstores](<https://devfeed.tech/topics/appstores.md>), [Google Play](<https://devfeed.tech/topics/google-play.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding-assistants](<https://devfeed.tech/tags/ai-coding-assistants.md>), [android](<https://devfeed.tech/tags/android.md>), [app](<https://devfeed.tech/tags/app.md>), [app-stability](<https://devfeed.tech/tags/app-stability.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [artificial-intelligence-ai](<https://devfeed.tech/tags/artificial-intelligence-ai.md>), [code](<https://devfeed.tech/tags/code.md>), [coding-assistants](<https://devfeed.tech/tags/coding-assistants.md>), [crash](<https://devfeed.tech/tags/crash.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [debug](<https://devfeed.tech/tags/debug.md>), [defense](<https://devfeed.tech/tags/defense.md>), [devices](<https://devfeed.tech/tags/devices.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [flag](<https://devfeed.tech/tags/flag.md>), [google-play](<https://devfeed.tech/tags/google-play.md>), [hotfix](<https://devfeed.tech/tags/hotfix.md>), [ios](<https://devfeed.tech/tags/ios.md>), [merge](<https://devfeed.tech/tags/merge.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [scale](<https://devfeed.tech/tags/scale.md>)

### AI overview

Grab manages mobile crash risk with layered checks that catch problems earlier and limit their impact. Android Lint and SwiftLint run on every merge request, blocking new high-severity findings; tests, QA, and a mandatory one-week Grab Early Access period catch runtime issues before production. Releases then expand through a monitored week-long staged rollout that can pause automatically, while feature flags allow gradual activation and instant shutdown. In production, crash-rate thresholds and trend alerts notify on-call engineers, who prioritize disabling a flag, applying a server-side fix, or shipping a hotfix followed by a post-mortem. Automated ticketing routes actionable crashes by severity. For hard-to-diagnose cases, Crashlytics data is exported to BigQuery for SQL analysis and dashboards, and sessions include metadata such as last screen, install source, and navigation history. Some environmental crashes are monitored and contained rather than treated as code defects.

### Source excerpt

Introduction Artificial intelligence (AI) coding assistants have changed how fast we can ship. They have not changed how mobile users experience a crash. That gap is the pressure every mobile stability program now operates under. The Grab superapp, which millions of users across Southeast Asia use to book rides, order food, and more, operates at a large scale. On Android alone, it spans millions of lines of code, with many engineers shipping code into every release on a weekly release cycle. Maintaining app stability is not just a technical goal; it is a product commitment to those users. With the rise of AI coding assistance, the volume of change in every release has grown, and so has the number of ways a single change can break something in an already large codebase. At this scale, crashes leaking into production are an ongoing risk. A high volume of merge requests lands every week across many product teams, many shipping features behind flags that are switched on independently of releases. Any one of those changes can introduce a crash. Most of the time, the stack trace points straight to the responsible change and team. The hard cases are the exceptions: crashes without a usable stack trace, such as native crashes without debug symbols, where finding the cause means cross-referencing release timelines, flag rollouts, and session metadata. The cost of a crash is also steeper on mobile than on the web. A web fix can go live in minutes; a mobile crash that ships stays on users' devices. With more than 100 million downloads on Google Play as of October 2026, not every user has auto-update enabled, and until a force update reaches them, some will run a broken version for months. Meanwhile, the crash degrades their experience, drags down the crash-free session rate, and can hurt the app's ranking on Google Play. If it is severe enough to need a hotfix, the team also has to prepare an out-of-cycle build, pulling time away from planned work. We keep the Grab superapp st

## GrabMart data for faster disease outbreak detection

DevFeed: [GrabMart data for faster disease outbreak detection](<https://devfeed.tech/articles/grabmart-data-for-faster-disease-outbreak-detection-85624.md>)

Original publisher: [Read original article](<https://engineering.grab.com/grabmart-data-for-faster-disease-outbreak-detection>)

Author: Muqi Li

Published: 2026-10-13T00:23:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Data analysis](<https://devfeed.tech/topics/data-analysis.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [Detection engineering](<https://devfeed.tech/topics/detection-engineering.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [bias](<https://devfeed.tech/tags/bias.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [governance](<https://devfeed.tech/tags/governance.md>), [health](<https://devfeed.tech/tags/health.md>), [outbreak](<https://devfeed.tech/tags/outbreak.md>), [process](<https://devfeed.tech/tags/process.md>), [public-health](<https://devfeed.tech/tags/public-health.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

The article outlines an early-stage proposal to use aggregated GrabMart purchases of symptom-related products as an additional signal for public health surveillance. It describes anomaly detection against seasonal baselines, statistical validation, and privacy and governance controls. The concept is not deployed, and the signal cannot diagnose disease or replace clinical surveillance.

### Source excerpt

Abstract Retail purchases can supplement clinical surveillance because changes in demand for some over-the-counter (OTC) products may appear before confirmed case reports. This article describes an early-stage concept for analysing aggregated GrabMart transaction data to identify unusual changes in product demand. The concept is not a deployed system, and it would require validation by public health experts, privacy review, and regulatory approval before any implementation. Introduction Public health agencies use sources such as clinical case reports, laboratory results, and hospital records to monitor disease activity. Retail data may offer an additional signal when demand changes across groups of symptom-related products. It cannot establish a diagnosis or replace clinical evidence. When using indirect signals, we should assess whether they remain relevant to the outcome we want to measure. This includes considering how changes in user behaviour could affect their interpretation. A retail-based signal can experience similar drift, selection bias, and false alarms. Any useful design must therefore combine statistical validation with careful privacy and governance controls. Background Syndromic surveillance tracks patterns that may indicate emerging illness before diagnoses are confirmed. Retail surveillance applies this idea to changes in demand for products associated with symptoms, such as fever remedies or cough medicines. The proposed method groups eligible products into broad symptom classes and measures changes in aggregate demand over time. An anomaly score can indicate that observed demand differs from an expected seasonal pattern. The score is a statistical signal, not an estimate of how many people have a disease. The design uses the following terms: Proposed solution The proposed pipeline would process only transactions that meet documented eligibility rules. It would map eligible SKUs to symptom classes, aggregate counts across approved time periods and

## Smarter personalization: How property data helps us understand user price sensitivity

DevFeed: [Smarter personalization: How property data helps us understand user price sensitivity](<https://devfeed.tech/articles/smarter-personalization-how-property-data-helps-us-understand-user-price-sensitivity-65186.md>)

Original publisher: [Read original article](<https://engineering.grab.com/price-sensitivity-profiling-using-llm>)

Author: Muqi Li

Published: 2026-10-06T00:23:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Data Science](<https://devfeed.tech/topics/data-science.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [clustering](<https://devfeed.tech/topics/clustering.md>), [personalization](<https://devfeed.tech/topics/personalization.md>), [Data analysis](<https://devfeed.tech/topics/data-analysis.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [enrichment](<https://devfeed.tech/tags/enrichment.md>), [personalization](<https://devfeed.tech/tags/personalization.md>), [user](<https://devfeed.tech/tags/user.md>)

### AI overview

The article describes a conceptual method for estimating user affluence and price sensitivity from public property data. It combines LLM-assisted data extraction with building-level price estimates, hierarchical clustering and geographic mapping to property tiers. The approach remains unimplemented, undeployed and untested, so its proposed uses in personalization, advertising and operational planning are not demonstrated.

### Source excerpt

Introduction Existing systems estimate user price sensitivity primarily from spending behavior or demographic proxies. They do not systematically account for residential property values, which can indicate a user's financial circumstances. This omission creates three limitations: Limited property insights: Existing profiles do not account for property values. One-dimensional profiles: Users with similar spending patterns but different living standards receive the same classification. Regional variation: Manual classification does not adapt well to differences between property markets. This invention adds property data to user profiles to produce affluence segments that account for regional property markets. The invention remains unimplemented and is not deployed in any live market. Background Property values vary across buildings, neighborhoods, and regions. A useful classification method must account for these differences while processing property records in several formats. The same classification method could support other industries that use affluence segments. Solution A four-step method that combines public property data with clustering techniques to classify user affluence was created: Data collection and enrichment. Building-level property price estimation. Property tier classification. User mapping to affluence tiers. The method combines external property data, large language model (LLM) enrichment, and cluster-based segmentation. The resulting profiles can inform personalized offers, targeted marketing, and operational planning. Data gathering and processing The system collects public property data from external sources. These records include transaction prices, building types, and related attributes in raw text formats. LLMs standardize the records and extract key attributes such as postcode, building address, transaction price, price per square meter, property size, and floor level. This stage produces a structured property-level dataset for analysis and

## Powering AI-led research through simulation

DevFeed: [Powering AI-led research through simulation](<https://devfeed.tech/articles/powering-ai-led-research-through-simulation-64809.md>)

Original publisher: [Read original article](<https://engineering.grab.com/powering-ai-led-research-through-simulation>)

Author: Henokh Fibrianto

Published: 2026-10-05T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [AI-enhanced product development](<https://devfeed.tech/topics/ai-enhanced-product-development.md>), [experiments](<https://devfeed.tech/topics/experiments.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [harvestbench](<https://devfeed.tech/topics/harvestbench.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [dispatch](<https://devfeed.tech/tags/dispatch.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [simulation](<https://devfeed.tech/tags/simulation.md>)

### AI overview

Grab describes sim-rs, a self-contained marketplace simulator that lets engineers and agents test dispatch strategies using reproducible runs and built-in comparisons. An automated research loop proposes changes, checks them against safeguards, and can also optimize simulator performance and keep its models aligned with production behavior.

### Source excerpt

The short story Consider a Friday evening. A food order arrives from a mall in the city center. One driver is nearby; another is finishing a drop-off and will be available shortly; a second order from the same mall may or may not appear in the next two minutes. Dispatch the nearby driver now, or hold briefly for a batching opportunity? The decision window is short. A fulfillment marketplace makes these decisions continuously. Each one is small. Across a city, those decisions determine whether your dinner arrives hot and whether a driver's hour is well spent. And that is one decision. There are dozens more: how far to look for a driver, when two orders are worth combining, which of three waiting trips gets the one free bike, how long to keep trying before giving up. These decisions interact, and the setting that is right for Friday at seven is wrong for Tuesday at two. Together they define a space of possible strategies far larger than anyone could exhaustively explore. We sample only about a dozen points in that space each year. Not for want of ideas: implementing each strategy costs weeks of engineering, and a production experiment takes weeks more to judge. Some questions have no production answer at all. Nobody can run last Saturday again with twenty percent fewer drivers. We were never short of compute resources, and never short of data. We were short of attempts. So we built sim-rs, a simulator that makes each attempt take minutes, and connected agents that run experiments on it. sim-rs is self-contained: it requires no production services or databases. The dispatch lifecycle runs in one compiled program alongside a separate dispatch service that is spawned locally and operates offline. Historical booking and driver data go in as plain files, together with a configuration describing the strategy to test. Simulated bookings, trips, drivers, and a single metrics report come out. Processing one city-day of marketplace activity takes tens of minutes, from raw input

## Automated merchant review summary system with integrated feedback

DevFeed: [Automated merchant review summary system with integrated feedback](<https://devfeed.tech/articles/automated-merchant-review-summary-system-with-integrated-feedback-64808.md>)

Original publisher: [Read original article](<https://engineering.grab.com/automated-merchant-review-summary-system-with-integrated-feedback>)

Author: Chengju Zhou

Published: 2026-09-25T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [human-in-the-loop UX](<https://devfeed.tech/topics/human-in-the-loop-ux.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [assessment](<https://devfeed.tech/tags/assessment.md>), [automated](<https://devfeed.tech/tags/automated.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [llm](<https://devfeed.tech/tags/llm.md>), [performance](<https://devfeed.tech/tags/performance.md>), [review](<https://devfeed.tech/tags/review.md>), [summary](<https://devfeed.tech/tags/summary.md>)

### AI overview

Grab describes a pipeline that samples merchant reviews, uses an LLM to generate overall and topic-based summaries, and applies a separate LLM quality check before publication. The system regenerates summaries when new-review counts or negative consumer feedback reach configured thresholds. Its authors note that sampling can miss segments of the customer experience, automated validation does not prove accuracy, and feedback triggers need anti-abuse controls.

### Source excerpt

Introduction Merchant reviews contain useful details about food quality, portion size, packaging, and value. Finding these details often requires reading many comments. Aggregate ratings simplify comparisons, but they do not explain what shaped each score. We built the Automated Merchant Review Summary System to turn written reviews into concise summaries. Consumers can scan an overall summary or focus on a specific topic. Merchants can identify what customers value and which parts of the experience need attention. This article focuses on how we generate and maintain consumer-facing review summaries. A misleading or incomplete summary can affect how consumers view a merchant. Merchant-facing recourse and dispute processes sit outside this pipeline and are not covered in this process flow. Problem statement A long, unstructured list of reviews creates two related problems. Consumers spend time searching for comments that match their priorities, while merchants must combine individual comments to identify recurring themes. Consumers may see hundreds or thousands of reviews for a merchant. Reading only the first few can produce an incomplete picture, while the aggregate star rating provides little context. Two restaurants with the same rating may differ in food quality, delivery experience, portion size, or value. Merchants face a related problem. Reading and classifying every review takes time, and the task becomes harder as review volume grows. Recurring complaints and positive patterns can remain hidden among individual comments. Existing approaches Manual review analysis Consumers and merchants can read reviews one by one and form their own conclusions. Their conclusions depend on which reviews they read and how they interpret them. This method becomes impractical as review volume grows. Aggregate star ratings An average score quickly indicates customer opinion but does not explain the reasons behind it. A merchant can see overall performance but not the themes tha

## Data Mesh at Grab (Part III): Operationalizing data reliability with automated DPIs

DevFeed: [Data Mesh at Grab (Part III): Operationalizing data reliability with automated DPIs](<https://devfeed.tech/articles/data-mesh-at-grab-part-iii-operationalizing-data-reliability-with-automated-dpis-1247.md>)

Original publisher: [Read original article](<https://engineering.grab.com/data-mesh-at-grab-part-three>)

Author: Harvey Li

Published: 2026-08-28T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [incident](<https://devfeed.tech/topics/incident.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [data](<https://devfeed.tech/tags/data.md>), [data-quality](<https://devfeed.tech/tags/data-quality.md>), [database](<https://devfeed.tech/tags/database.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [incident](<https://devfeed.tech/tags/incident.md>), [mesh](<https://devfeed.tech/tags/mesh.md>), [observability](<https://devfeed.tech/tags/observability.md>), [platform](<https://devfeed.tech/tags/platform.md>), [production](<https://devfeed.tech/tags/production.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Grab describes an automated Data Production Issue lifecycle for maintaining reliable data products. An incident orchestrator checks data-contract health, starts a DPI when contract tests fail, and distinguishes alerts from confirmed contract breaches.

### Source excerpt

Introduction In the first two parts of this series, we described how Grab approaches data mesh through the Signals Marketplace: a way for teams to publish, discover, and reuse trusted data products across domains. Part II introduced the foundational tools behind certification: Hubble for metadata and ownership, Genchi for data quality observability, and the Data Contract Registry for explicit producer-consumer guarantees. Certification is the starting point for a trusted data marketplace. It gives downstream consumers confidence in an asset's ownership, documentation, lineage, and quality controls. Certification does not eliminate runtime failure. A certified table can still arrive late. A certified metric can still be affected by a broken dependency. A certified Kafka stream can still violate a freshness expectation. Keeping certified data products reliable in production requires more than defining standards upfront. Teams need a consistent way to detect failures, diagnose the root cause, fix the issue, and verify recovery. That is where Data Production Issues (DPIs) come in. At Grab, DPIs turn data quality signals into an operational workflow. The DPI lifecycle A good DPI should be clear enough to act on, and it should close automatically when the underlying condition recovers. From the beginning, we designed the DPI lifecycle to be automated, with minimal human-in-the-loop. The lifecycle starts when Kinabalu, Grab's incident orchestrator, observes that a data asset may no longer satisfy its contract. The contract captures the reliability expectations that matter for the asset, along with the health checks, exposed through Test Health application programming interfaces (APIs), that evaluate those expectations. The orchestrator stays decoupled from platform internals. It does not need to know how each platform computes freshness, completeness, or other quality dimensions. It only needs to ask whether the relevant contract tests are healthy. If one or more contract

## Building Jarvis Pro: Route first, answer later

DevFeed: [Building Jarvis Pro: Route first, answer later](<https://devfeed.tech/articles/building-jarvis-pro-route-first-answer-later-1251.md>)

Original publisher: [Read original article](<https://engineering.grab.com/jarvis-pro-route-firsr-answer-later>)

Author: Christian Coffrant

Published: 2026-08-21T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [account-management](<https://devfeed.tech/tags/account-management.md>), [ai](<https://devfeed.tech/tags/ai.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [business](<https://devfeed.tech/tags/business.md>), [classification](<https://devfeed.tech/tags/classification.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [llm](<https://devfeed.tech/tags/llm.md>), [product](<https://devfeed.tech/tags/product.md>), [routing](<https://devfeed.tech/tags/routing.md>)

### AI overview

Grab describes Jarvis Pro, an AI assistant for account managers that routes a request to a constrained task type before generating an answer. The design aims to avoid confident but unsuitable merchant recommendations, and reports offline routing and answer-quality evaluation results.

### Source excerpt

Introduction The first Jarvis Pro prototype could produce answers that sounded right. That was the problem. One early answer looked polished: it named the merchant, summarized the week, and recommended pushing promotions before the next review. It was also wrong. The merchant's order volume was down, but the sharper issue was operational: more outlets were paused and fulfilment had slipped. Sending more demand into that setup would have made the merchant look worse. That failure changed how we judged the system. Fluent was not enough. Jarvis Pro is the AI assistant we built for Grab account managers. Its job is to help them turn account data into better merchant conversations: what changed, why it changed, and what to do next. They rarely ask clean dashboard questions. They ask: "I am meeting this merchant tomorrow. What should I tell them?" or "Which accounts in my portfolio need attention this week?" Those questions hide decisions: scope, access, business diagnosis, and metric definition. If the system gets those wrong, confidence becomes a liability. So the core design became: route first, answer later. In an internal offline evaluation (not a measure of production performance or business impact), routing matched the expected safe route for 99.4% of 351 realistic prompts drawn from labelled eval sets from the first half of 2026. In a focused portfolio and brand answer-quality suite, the average score moved from 78.5 to 91.0. These figures come from offline launch-readiness evaluation only; they are not business-impact proof. Why dashboards were easier A dashboard answers a bounded question: "Show net sales for merchant X last week." An account review question has to diagnose the work to be done: "This merchant softened this week. Should I push promos, ads, or operations fixes before the review?" If outlets were paused, more traffic can backfire. If average order value fell, the next action may be menu or bundle design. If a dashboard, warehouse table, and local s

## Grab Bench: Evaluating AI on Grab-shaped production work

DevFeed: [Grab Bench: Evaluating AI on Grab-shaped production work](<https://devfeed.tech/articles/grab-bench-evaluating-ai-on-grab-shaped-production-work-1248.md>)

Original publisher: [Read original article](<https://engineering.grab.com/grab-bench-evaluating-ai>)

Author: Christian Coffrant

Published: 2026-08-12T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Human-AI evaluation](<https://devfeed.tech/topics/human-ai-evaluation.md>), [Language models](<https://devfeed.tech/topics/language-models.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [code](<https://devfeed.tech/tags/code.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [llm](<https://devfeed.tech/tags/llm.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [product](<https://devfeed.tech/tags/product.md>), [production](<https://devfeed.tech/tags/production.md>), [safety](<https://devfeed.tech/tags/safety.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

Grab Bench is a configurable evaluation harness for AI systems performing production-shaped tasks. It evaluates failures in SQL generation, tool calling, profile updates, and coding agents using task plugins, row-level records, deterministic scorers, or LLM judges.

### Source excerpt

Introduction What worried us wasn't the hallucination, it was the subtle plausibility. Answers an engineer could easily read past and accept: a right-looking Structured Query Language (SQL) query, a plausible tool call, an innocent profile update, or a patch that satisfied the surface tests. When we analyzed the row-level failures, a clear pattern emerged: SQL generation: kept the query shape but changed the underlying metric. Tool calling: selected the right tool family but drifted on parameters. Profile updates: cited every event instead of only the evidence that supported the claim. Coding agents: passed visible tests while missing a hidden stateful invariant. Grab Bench bridges this exact gap. Grab Bench is a configurable eval (evaluation) harness for artificial intelligence (AI) systems on Grab-shaped work. It runs model providers through task plugins, records one row per case/model pair, and uses deterministic scorers or large language model (LLM) judges depending on the task. We treat the eval like software: version it, run baselines, keep score records, and make the failure modes visible enough for a team to debug. This write-up focuses on the design choices behind that work. The problem: plausible is not correct Public leaderboards are still useful; we read them too. They just answer a different question. A product team needs to know whether a model can preserve a metric definition, obey an internal tool contract, stay cautious with weak evidence, or make a code change without breaking behaviour hidden from the prompt. The hard part is that real examples are rarely reusable as-is. Production traces, schemas, user records, and internal workflows need protection. So the benchmark has to preserve the shape of the work without depending on the work itself. That constraint shaped Grab Bench from the beginning. Some surfaces stay internal. Others use synthetic or redacted cases. Either way, the case has to keep the thing that makes the work hard: metric faithfuln

## How AI is transforming analytics at Grab

DevFeed: [How AI is transforming analytics at Grab](<https://devfeed.tech/articles/how-ai-is-transforming-analytics-at-grab-1249.md>)

Original publisher: [Read original article](<https://engineering.grab.com/how-ai-is-transforming-analytics>)

Author: Maanas Prabhakar

Published: 2026-08-01T00:23:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [data](<https://devfeed.tech/topics/data.md>), [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Grab describes how increasingly capable AI agents are transforming analytics by automating data preparation, query writing, analysis, experiment design, result interpretation, and commentary. The article presents an autonomy ladder in which agents take ownership of more of the analytics loop while humans retain accountability for problem framing, metric definitions, causal reasoning, business assumptions, decisions, and stakeholder relationships.

### Source excerpt

Introduction At Grab, analytics sits close to almost every decision that matters. Our north star is the democratisation of intelligence, ensuring that anyone making a business call has immediate access to trustworthy answers. Over the last two years, model capability has crossed a threshold enabling this shift. Agents now do in minutes what used to take a week: preparing the data, writing queries, running deep analysis and developing insights for business opportunities, designing experiments and interpreting the results, drafting the commentary that follows, and more. Our throughput is no longer rate-limited by how fast an individual can write code, build a deck, or run a deep-dive. It is rate-limited by how fast we can frame the right problem, judge the right answer, and influence the right decision. As autonomy climbs, an analyst's impact moves from producing the artefact to owning the question and the call behind it, and the role evolves to become part builder, part advisor, part strategist, owning the loop rather than running it. That unlocks two things at once: work we already do, faster and at lower marginal cost, and work we could never staff before, sitting beside every product manager, business owner, and operator at the moment they decide. The ladder We were heavily inspired by Dan Shapiro's framing of five levels for AI coding. We use a similar ladder that defines how much of the loop an agent should own and where human judgement stays for every analytics loop. One distinction runs across every level: who owns the loop, and where human judgement is required. Level What Human role Agent role L2 AI-Assisted Owns and executes every step; uses AI to draft, suggest, summarise Drafts SQL, suggests a visualisation L3 Human plans, agent owns steps, human reviews Frames the question, picks the metric, the segment, and the comparison frame, reviews evidence, owns the recommendation Discovers data, writes and runs the query, sanity checks, drafts the write-up, flags

## Crowdsourced taxonomy verification: A feedback-driven framework for refining knowledge graph relationships via online search interactions

DevFeed: [Crowdsourced taxonomy verification: A feedback-driven framework for refining knowledge graph relationships via online search interactions](<https://devfeed.tech/articles/crowdsourced-taxonomy-verification-a-feedback-driven-framework-for-refining-knowledge-graph-relationships-via-online-search-interactions-1246.md>)

Original publisher: [Read original article](<https://engineering.grab.com/crowdsourced-taxonomy-verification>)

Author: Junpeng Niu

Published: 2026-07-30T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [AI search](<https://devfeed.tech/topics/ai-search.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Language models](<https://devfeed.tech/topics/language-models.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [knowledge-graph](<https://devfeed.tech/tags/knowledge-graph.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [llm](<https://devfeed.tech/tags/llm.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [search](<https://devfeed.tech/tags/search.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

The article presents a feedback-driven system for verifying knowledge-graph relationships through live search interactions. It tests unverified parent-child or sibling edges in search suggestions, measures user engagement, and uses greedy exploration to balance data collection with result quality.

### Source excerpt

Introduction The efficacy of semantic search relies on the accuracy of the underlying Knowledge Graph (KG). In high-velocity domains like on-demand food delivery or e-commerce, the catalog of entities like dishes, products, and merchants changes rapidly. Current methods for KG construction and maintenance face three critical challenges: Inaccuracy and hallucination from Large Language Models (LLMs): Automated models often infer relationships based on statistical text co-occurrence rather than semantic reality. For instance, an LLM might incorrectly classify "Pho" as a child of "Italian Noodle Soup" due to linguistic similarity, leading to irrelevant search results. Scalability limits of manual verification: Traditional verification relies on human annotators or domain experts. This approach is slow, expensive, and unable to keep pace with dynamic catalogs containing millions of entities. For example, daily changes in restaurant menus or grocery stock keeping units (SKUs). Error propagation in ranking: Inaccurate graph edges propagate errors downstream. If a parent-child relationship is wrong, query expansion algorithms will retrieve irrelevant items, directly degrading Click-Through Rate (CTR) and user trust. We introduce a feedback-driven verification engine that operationalizes the search interface as a validation environment. Key contributions include: User feedback-driven verification: The system treats unverified graph edges as hypotheses. Instead of accepting them as truth, it tests them against live traffic by injecting them into search suggestions and measuring user engagement. Hierarchical relationship refinement: Unlike systems that only validate entities (nodes), this framework validates structural links (edges). It confirms whether entity A is truly a parent, child, or sibling of entity B, ensuring structural integrity. Adaptive exploration: The system employs a greedy exploration policy. It intelligently balances exploitation by showing known good resul

## Agent platform (Part 1): How we help Grab build and run AI agents at scale

DevFeed: [Agent platform (Part 1): How we help Grab build and run AI agents at scale](<https://devfeed.tech/articles/agent-platform-part-1-how-we-help-grab-build-and-run-ai-agents-at-scale-1250.md>)

Original publisher: [Read original article](<https://engineering.grab.com/how-grab-builds-and-runs-ai-agents-at-scale>)

Author: Kendrick Tan

Published: 2026-07-24T00:00:10Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [AI Bots](<https://devfeed.tech/topics/ai-bots.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [MSP MCP](<https://devfeed.tech/topics/msp-mcp.md>)

Tags: [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-infrastructure](<https://devfeed.tech/tags/ai-infrastructure.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [design](<https://devfeed.tech/tags/design.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [go](<https://devfeed.tech/tags/go.md>), [llm](<https://devfeed.tech/tags/llm.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [platform](<https://devfeed.tech/tags/platform.md>), [scale](<https://devfeed.tech/tags/scale.md>)

### AI overview

Grab describes the first part of its AI-agent platform story: a Tech Infra support bot that evolved from operational automation into a GPT-powered Level-0 support layer. The article outlines its reasoning and tool planes and explains how scaling challenges informed the LLM-Kit framework.

### Source excerpt

Part 1: From one support bot to a framework At Grab, AI agents have evolved from interesting team prototypes into production services used every day by millions of merchants, drivers, and consumers. Today, more than 500 services run on our internal agent framework, over 50 Model Context Protocol (MCP) servers are registered on our remote MCP framework, and a single Large Language Model (LLM) gateway fronts every model call across the company, handling billions of tokens each month. None of this was designed up front. It began as the plumbing behind one internal support bot, which then expanded because the same problems kept resurfacing for every team trying to ship an agent. This series tells the story of what the platform eventually became. This Part 1 of the blog focuses on the beginning: the architecture of our AI support bot, the specific pain points we hit while scaling and iterating on it, and how each of those failures became a core building block in the framework we now call LLM-Kit. The bot that started it Imagine you have a question for the Technical Infrastructure (Tech Infra) team - the engineers who run the cloud platforms, databases, developer tooling, and AI infrastructure behind Grab's ecosystem. Instead of immediately paging an on-call engineer, a bot first triages the request, checks the team's documentation, runbooks, and past Slack threads, and tries to answer directly in the thread. If it still cannot resolve the issue, it routes the ticket to the right human, with the relevant context already attached. That is what we built with the Tech Infra Support Bot. In the first half of 2023, Tech Infra handled thousands of support tickets, many of them repeated questions that had already been answered somewhere internally. Before LLMs, the bot's role was mainly operational; performing tasks like helping track acknowledgments and response times for on-call engineers. With the arrival of GPT-4-32k, we evolved it into a GPT-powered Level-0 support layer th

## Scaling Grab's Data Lake: Our journey to Apache Iceberg adoption

DevFeed: [Scaling Grab's Data Lake: Our journey to Apache Iceberg adoption](<https://devfeed.tech/articles/scaling-grab-s-data-lake-our-journey-to-apache-iceberg-adoption-1252.md>)

Original publisher: [Read original article](<https://engineering.grab.com/our-journey-to-apache-iceberg-adoption>)

Author: Rahul Penti

Published: 2026-07-10T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>), [data](<https://devfeed.tech/topics/data.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [parquet](<https://devfeed.tech/topics/parquet.md>), [Apache Spark](<https://devfeed.tech/topics/spark.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [compute](<https://devfeed.tech/tags/compute.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [latency](<https://devfeed.tech/tags/latency.md>), [parquet](<https://devfeed.tech/tags/parquet.md>), [performance](<https://devfeed.tech/tags/performance.md>), [s3](<https://devfeed.tech/tags/s3.md>), [scale](<https://devfeed.tech/tags/scale.md>), [spark](<https://devfeed.tech/tags/spark.md>)

### AI overview

Grab describes its transition from Hive Parquet and a directory-based Hive Metastore architecture toward Apache Iceberg and a table-centric lakehouse. The article outlines scalability problems involving metadata latency, small files, S3 request overhead, and operational management, and mentions a unified Spark catalog built to hide table-format differences.

### Source excerpt

Introduction: The evolution of Grab's Data Lake At Grab's scale, managing petabytes of data across billions of S3 objects demands more than a storage layer. It demands a robust architectural primitive that supports the high-concurrency needs of a modern "Lakehouse." Our goal is full storage-compute separation, leveraging S3 as an elastic foundation for both near-real-time metrics and large-scale batch transformations. For years, the vast majority of our tables were Hive Parquet, managed through the Hive Metastore with a directory-based layout. This model served us well, but as data volume grew, the directory-and-metastore approach became the limiting factor. We are now transitioning to a table-centric architecture built on modern table formats, treating data as a first-class primitive to ensure consistency and performance across our internal data transformation platforms: Slide, which powers batch transformations, and Hugo, which handles online-to-data-lake ingestion. Along the way, we also built the UnifiedSparkCatalog, a unified Spark catalog that hides table-format differences from users entirely, which we are open-sourcing alongside this post. The catalyst for change: Challenges with Hive Parquet For years, Hive Parquet was the backbone of our Data Lake, representing the vast majority of our tables. However, as data volume scaled, the architectural limitations of directory-based storage became apparent. We identified four primary bottlenecks: Catalog latency: The Hive Metastore (HMS) became a centralized failure point. High concurrency during metadata access led to O(n) listing overhead, where query planning time scaled linearly with partition count, crippling throughput. The small file problem: The directory layout left us with severe file fragmentation. Certain Machine Learning (ML) datasets had an average file size under 1 MB, with thousands of files in each partition. At this scale, the overhead of S3 object listing and metadata request latency drove up Appl

## Migrating Counter Service storage: Design choices and learnings

DevFeed: [Migrating Counter Service storage: Design choices and learnings](<https://devfeed.tech/articles/migrating-counter-service-storage-design-choices-and-learnings-1245.md>)

Original publisher: [Read original article](<https://engineering.grab.com/counter-service-storage-migration>)

Author: Jia Long Loh

Published: 2026-07-03T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [migration](<https://devfeed.tech/topics/migration.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Back end](<https://devfeed.tech/topics/backend.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [backend](<https://devfeed.tech/tags/backend.md>), [database](<https://devfeed.tech/tags/database.md>), [devsecops](<https://devfeed.tech/tags/devsecops.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [latency](<https://devfeed.tech/tags/latency.md>), [migration](<https://devfeed.tech/tags/migration.md>), [platform](<https://devfeed.tech/tags/platform.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [security](<https://devfeed.tech/tags/security.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

Grab's Counter Service migrated its storage backend from a wide-column database to Aerospike to support a high-volume, low-latency fraud-detection workload. The article describes separating storage from business logic, revisiting data modeling and access patterns, and designing reader- and writer-side changes for a gradual, observable rollout.

### Source excerpt

Introduction Counter Service is used across Grab's anti-fraud platform to answer time-windowed count questions, such as recent ride requests by a user or failed payment attempts on a card. The service handles tens of thousands of queries per second (QPS) with about a billion requests per day, while maintaining strict requirements around latency and reliability to support real-time fraud rule evaluation. For most of its life, Counter Service was backed by a wide-column database that served the workload reliably as the service scaled. As part of a broader infrastructure review mandated at an organizational level, our database team evaluated alternatives to this storage that many services relied on, including Counter Service. Based on their assessment, Aerospike emerged as a good fit for our use-case. We also used the migration as an opportunity to decouple storage concerns from business logic, a necessary first step for this migration, and one that would reduce the effort required for future storage changes. As part of the same effort, we revisited the data model and access patterns in detail, which helped us identify and apply several straightforward optimizations. This post walks through how we did it. What we built on the reader-side to make the migration safe, how we redesigned the writer-side data model around the new backend, and what we ran into during the gradual rollout. Setting the stage Counter data is stored in three time granularities: 15-minute, hourly, and daily buckets. A typical read would be along the lines of, "give me the count for key X over the last 90 minutes", which the service decomposes into the smallest possible set of buckets, one hourly in the middle, a few 15-minute buckets at the edges, fetches them, and sums. In the original setup, each granularity was stored in a separate table with a composite primary key: TABLE daily_count ( key TEXT, -- partition key day_ts TIMESTAMP, -- clustering key count BIGINT, PRIMARY KEY (key, day_ts) ); The

## Scaling out Distroless adoption With AI

DevFeed: [Scaling out Distroless adoption With AI](<https://devfeed.tech/articles/scaling-out-distroless-adoption-with-ai-1254.md>)

Original publisher: [Read original article](<https://engineering.grab.com/scaling-out-distroless-adoption-with-ai>)

Author: Jia Yee Chong

Published: 2026-06-22T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Security](<https://devfeed.tech/topics/security.md>), [migration](<https://devfeed.tech/topics/migration.md>), [Dockerfile](<https://devfeed.tech/topics/dockerfile.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [make](<https://devfeed.tech/topics/make.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Docker](<https://devfeed.tech/topics/docker.md>), [Docker Image](<https://devfeed.tech/topics/docker-image.md>), [Testcontainers](<https://devfeed.tech/topics/testcontainers.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [ci](<https://devfeed.tech/tags/ci.md>), [containers](<https://devfeed.tech/tags/containers.md>), [devsecops](<https://devfeed.tech/tags/devsecops.md>), [docker](<https://devfeed.tech/tags/docker.md>), [docker-image](<https://devfeed.tech/tags/docker-image.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [migration](<https://devfeed.tech/tags/migration.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [security](<https://devfeed.tech/tags/security.md>), [testcontainers](<https://devfeed.tech/tags/testcontainers.md>), [testing](<https://devfeed.tech/tags/testing.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Grab describes migrating services from heavy base images to Distroless images to reduce security risks and eliminate unnecessary binaries and associated CVEs. The article explains the runtime-failure risks of this migration and presents medium tests using Docker images, Testcontainers, and network proxies to verify configuration and runtime dependencies in CI.

### Source excerpt

Distroless adoption at Grab Grab is migrating from heavy base images to Distroless images to reduce security risks. By limiting each container to the application and its runtime dependencies, we shed non-essential binaries and associated Common Vulnerabilities and Exposures (CVEs). This migration is more than a compliance mandate; it is a strategic security decision to build a more resilient environment. Why Distroless requires rigorous testing Distroless adoption risk: Runtime failure Shifting to Distroless images introduces a critical technical risk: Runtime Failure. A service might build perfectly in Continuous Integration (CI), but fail at the deployment stage due to: Missing shared objects: Binaries might require specific libraries (.so files) present in Ubuntu but absent in Distroless. Implicit links: Third-party tools might expect specific system utilities or directory structures. Testing is required to ensure two things: The service spins up with the correct configuration. All runtime dependencies remain intact. Scaling this verification across thousands of services manually? That would take years, unless we found a way to automate the trust. The testing methodology As we perform changes to the Dockerfile definition of our services, it is important for us to include the corresponding test strategy to ensure that the changes that we make do not introduce a regression to our running services. Assessing the change introduced to our services, the lowest possible testing boundary would be that of what we define as medium tests in Grab. Medium tests in Grab At Grab, we categorize our test suites into 3 main sizes: small, medium and large. Small tests refer to functional tests whereby mocks are introduced via dependency injection. Large tests refer to end-to-end tests that run on actual services in our staging environment where nothing is mocked. Figure 1: Architecture diagram of a medium test environment Medium tests sit between the small and large tests. External

## Palana (Part 2): Architecting isolation, identity, and auditability for AI agents

DevFeed: [Palana (Part 2): Architecting isolation, identity, and auditability for AI agents](<https://devfeed.tech/articles/palana-part-2-architecting-isolation-identity-and-auditability-for-ai-agents-1253.md>)

Original publisher: [Read original article](<https://engineering.grab.com/part-2-palana-architecture>)

Author: Kevin Littlejohn

Published: 2026-06-21T00:00:00Z

Content type: article

Language: en

Sources: [Grab Tech](<https://devfeed.tech/sources/grab-tech.md>)

Topics: [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [systems](<https://devfeed.tech/topics/systems.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Network](<https://devfeed.tech/topics/network.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Filesystems](<https://devfeed.tech/topics/filesystems.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [devsecops](<https://devfeed.tech/tags/devsecops.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [http](<https://devfeed.tech/tags/http.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [llm](<https://devfeed.tech/tags/llm.md>), [network](<https://devfeed.tech/tags/network.md>), [observability](<https://devfeed.tech/tags/observability.md>), [platform](<https://devfeed.tech/tags/platform.md>), [policy](<https://devfeed.tech/tags/policy.md>), [production](<https://devfeed.tech/tags/production.md>), [resource](<https://devfeed.tech/tags/resource.md>), [secrets](<https://devfeed.tech/tags/secrets.md>), [security](<https://devfeed.tech/tags/security.md>), [systems](<https://devfeed.tech/tags/systems.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Palana Part 2 explains the architecture of Grab's Kubernetes-native secure execution platform for autonomous AI agents. It describes isolated user-and-agent namespaces, default-deny networking, proxy-mediated traffic, Vault-based secret separation, operator-managed resources, admission controls, persistent storage, observability signals, and identity handling.

### Source excerpt

Introduction In Part 1, we introduced Palana, Grab's Kubernetes-native secure execution platform for autonomous AI agents. We discussed the underlying need for isolated environments and covered its core design principles: treating isolation as the unit of trust, keeping credentials out of agent hands, and mediating all network access. In this second part, we'll dive under the hood into Palana's architecture, look at the agent lifecycle, and share the key lessons we learned from putting this system into production. Architecture overview The core request path looks like this: Figure 1. Palana architecture overview. The agent pod runs in a namespace owned by one user and one agent. It gets default-deny style network policy, domain name system (DNS), access to required platform services, and a persistent /data volume. Browser traffic enters through Traefik. LLM traffic goes to the LiteLLM wrapper in the gateway namespace. General Hypertext Transfer Protocol (HTTP) and Hypertext Transfer Protocol Secure (HTTPS) egress goes through the proxy namespace. Secrets are read from Vault only by the component authorized to use them. The operator is responsible for turning a user request into the concrete Kubernetes shape: The user creates an agent through pcli (Palana command-line interface) or the portal. Palana writes a UserAgent or Agent custom resource with the raw user identity. The operator creates the user and agent namespaces, service accounts, role bindings, storage, network policies, and ingress. The user runs a template or container image. Admission webhooks inject proxy environment variables and enforce pod-level restrictions. Logs, policy decisions, and activity signals are emitted to observability systems. Agent lifecycle From a user's perspective, the basic workflow is intentionally small: ./pcli login ./pcli create demo ./pcli secrets add demo GRABGPT_API_KEY token=<token> ./pcli run demo --template claudecodeui Behind those commands, Palana provisions an isolated