Techlist.io - Korean Tech Blog Curator

gitlab2 min readCurated summary

How to detect and prevent Contagious Interview IDE attacks

Contagious Interview attacks abuse VS Code’s automated tasks to execute malware when victims open a malicious repository and trust its workspace. GitLab developed low-level EDR detections around `node-pty`’s `spawn-helper`, allowing it to identify hidden background process execution while avoiding normal interactive developer activity. The article recommends combining runtime detection with IDE configuration hardening. ## The Contagious Interview Attack Path - North Korean threat actors use fake job interviews to persuade targets to download and review malicious code repositories. - Repositories can include a `.vscode/tasks.json` file configured to run automatically when the folder opens. - After the victim grants workspace trust, the task executes without obvious interaction. - Example payloads: - Detect the operating system. - Download a platform-specific second-stage payload. - Pipe it directly into `bash`, `sh`, or `cmd` using patterns such as `curl | bash`. - Resulting malware may steal passwords and cryptocurrency, deploy infostealers, and establish persistence for abuse of corporate access. ## Low-Level Detection with `spawn-helper` - GitLab looked below the VS Code layer because similar attacks can affect VS Code forks and other Node- or Electron-based IDEs. - VS Code uses the popular `node-pty` library to launch subprocesses. - `node-pty.spawn()` invokes a `spawn-helper` binary, which becomes a child process of the Node application. - This makes `spawn-helper` a useful operating-system-level signal for background task execution. ## Reducing False Positives - GitLab used Purple Team exercises to reproduce the attack and reviewed EDR telemetry. - Background VS Code tasks use `spawn-helper`, while foreground interactive processes such as the integrated terminal use a Code Helper binary. - Detections can therefore focus on processes launched invisibly, without user interaction. - GitLab further tuned alerts to identify suspicious commands such as background `curl | <shell>` execution rather than flagging every automated task. - The resulting detection produced no false positives despite widespread VS Code usage internally. ## Additional Prevention Measures - Runtime EDR monitoring is only one layer of defense. - Organizations can proactively harden their fleets by deploying global VS Code configuration that disables automatic task execution. - Combining IDE restrictions with process telemetry and behavioral detection provides broader protection against malicious repository-based attacks. Organizations should disable automatic task runs where practical and monitor low-level subprocess behavior, especially invisible `spawn-helper` executions that download or pipe remote content into a shell.

Read original(opens in new tab)
netflix3 min readCurated summary

State of Routing in Model Serving

Netflix’s centralized ML serving platform provides a single, domain-independent API for model inference across personalized experiences and other use cases. Rather than exposing individual scoring functions, Netflix packages feature computation, preprocessing, inference, and postprocessing into self-contained model workflows. The core routing challenge is directing each request to the correct model version and serving cluster while keeping client services independent from model changes and infrastructure topology. ## Models as End-to-End Workflows - Netflix distinguishes **model serving** from traditional model inference: - Inference typically means `infer(features) -> score`. - Serving includes preprocessing, feature computation, optional trained components, and postprocessing. - Example workflows include: - Ranking titles for a personalized Continue Watching row using user, country, and device context. - Predicting payment fraud using user, country, and transaction details. - Models declare the facts they need, while the serving platform retrieves those facts from other microservices. - During offline training, Netflix’s ML fact store provides snapshots for bulk feature computation. - Calling services provide standard request context and domain-specific inputs, while the platform handles feature generation, model selection, and execution. ## Platform Design Principles - **Model innovation without client changes** - Client applications integrate with the platform once. - Model versions, A/B tests, additional experimental data, logging, and model selection remain hidden behind the platform API. - **Clients decoupled from model sharding** - Models run across multiple serving cluster shards, each with its own Virtual IP address. - Shard assignments can change based on traffic, SLAs, model architecture, and resource availability. - Clients should not need to track these VIP changes. - **Flexible traffic routing** - Routing must support A/B allocations, gradual traffic shifts, new model versions, new VIPs, and client-specific overrides. - Safe lifecycle management requires support for shadow deployments, canaries, rollbacks, and migrations. ## Switchboard: Context-Aware Routing - Generic API gateways and service-mesh proxies did not satisfy Netflix’s requirements. - Netflix needed: - Native integration with its experimentation platform. - gRPC support. - Routing based on rich, domain-specific request context. - Model-specific rollout and migration controls. - Netflix built **Switchboard**, a custom proxy layer handling more than one million requests per second. - Switchboard is the mandatory entry point for clients and: - Routes requests to the appropriate model based on request context. - Applies configured context enrichment before invoking the model. - Hides model locations and infrastructure changes from client services. ## Objective Abstraction - Every request must provide an **Objective**, an enumeration defined by the serving platform. - The excerpt introduces Objectives as a central abstraction for identifying the business purpose of a serving request, but the supplied text ends before describing its full roles. Netflix’s approach is to centralize routing, experimentation, and model execution behind one stable API. This allows client applications to evolve independently while researchers can iterate on models and safely manage large-scale production rollouts.

Read original(opens in new tab)
cloudflare3 min readCurated summary

Code Orange: Fail Small is complete. The result is a stronger Cloudflare network

Cloudflare’s “Code Orange: Fail Small” initiative rebuilt key parts of its infrastructure to prevent repeats of the November 18 and December 5, 2025 global outages. The work focused on safer configuration rollouts, smaller failure impact, stronger emergency access, and improved incident communication. Cloudflare concludes that the network is now more resilient, though reliability remains an ongoing effort. ## Safer Configuration Changes - Configuration changes affecting customer traffic are now deployed progressively rather than instantly across the network. - Health monitoring can detect problems early and automatically roll back faulty changes. - Cloudflare introduced **Snapstone**, a unified system that: - Packages configuration changes. - Releases them gradually. - Monitors system health in real time. - Automatically rolls back unsafe deployments. - Snapstone supports different configuration types, including data files and global control flags. - New high-risk configuration pipelines have been identified and brought under the health-mediated deployment process. ## Reducing the Impact of Failure - Product teams reviewed failure modes and removed unnecessary runtime dependencies. - Systems now use the last known good configuration where possible, following a **“fail stale”** strategy. - Where stale configuration is unavailable, teams choose between: - **Fail open:** Continue serving traffic with reduced protection or functionality. - **Fail close:** Stop processing when that is safer than continuing. - The Bot Management outage scenario would now be detected during an early rollout stage, affecting only a small amount of traffic before rollback. - Services are increasingly segmented into independent systems serving different customer cohorts. - For example, the Workers runtime deploys first to less-critical segments, such as free customers, before reaching more critical traffic. - This approach limits the blast radius of faulty deployments and adjusts rollout speed based on customer criticality. - Cloudflare plans to extend cohort-based deployment to more systems. ## Revised Break-Glass and Incident Procedures - Cloudflare audited tools needed for visibility, debugging, and emergency production changes. - It created backup authorization paths for **18 key services**, along with emergency scripts and proxies. - These pathways are designed to remain usable if Cloudflare’s own Zero Trust infrastructure is affected by an outage. - More than 200 engineers participated in an organization-wide emergency drill on April 7, 2026. - Repeated exercises are intended to ensure engineers can use emergency access procedures effectively under pressure. - Cloudflare also began improving how technical incident observations are converted into clear customer communications. Cloudflare’s changes make configuration rollouts safer, reduce failure blast radius, and improve emergency response. The practical recommendation is to treat these safeguards as ongoing operational practices rather than a one-time project, continually testing them and extending them to additional systems.

Read original(opens in new tab)
meta2 min readCurated summary

How Meta Is Strengthening End-to-End Encrypted Backups

Meta’s HSM-based Backup Key Vault supports end-to-end encrypted backups for WhatsApp and Messenger by storing recovery codes in tamper-resistant hardware that Meta and third parties cannot access. The geographically distributed vault uses majority-consensus replication for resilience. Meta is strengthening the system with over-the-air fleet-key distribution for Messenger and public evidence of secure HSM fleet deployments. ## Over-the-Air Fleet Key Distribution - Clients verify HSM fleet authenticity using fleet public keys before establishing sessions. - WhatsApp embeds these keys directly in the application. - Messenger can receive keys over the air, allowing Meta to deploy new HSM fleets without requiring an app update. - Keys are delivered in validation bundles: - Signed by Cloudflare - Counter-signed by Meta - Recorded in a Cloudflare audit log - The complete validation process is documented in Meta’s *Security of End-To-End Encrypted Backups* whitepaper. ## Transparent HSM Fleet Deployment - Meta plans to publish evidence of the secure deployment of every new HSM fleet. - Users will be able to verify deployment evidence using the audit procedures in the whitepaper. - Deployments are expected to occur infrequently, generally no more than once every few years. - The transparency initiative is intended to demonstrate that Meta cannot access users’ encrypted backups. The system combines tamper-resistant HSMs, geographic replication, independently verifiable key distribution, and public deployment evidence. Readers seeking implementation details should consult the full whitepaper.

Read original(opens in new tab)
cloudflare3 min readCurated summary

Introducing Dynamic Workflows: durable execution that follows the tenant

Dynamic Workflows extends Cloudflare’s durable execution system to multi-tenant and dynamically generated applications. While Dynamic Workers provide isolated runtime compute, Durable Object Facets provide tenant-specific storage, and Artifacts provide versioned source control, Dynamic Workflows lets each tenant supply its own long-running workflow code. The result is durable execution that can resume the correct tenant’s workflow after failures, hibernation, or delays of days. ## The Gap Between Durable and Dynamic Execution - Cloudflare Workflows turns a `run(event, step)` function into a durable program. - Workflow steps can: - Survive isolate recycling and failures - Sleep for hours or days - Wait for external events - Resume from the exact point where execution stopped - Workflows V2 supports up to 50,000 concurrent instances and 300 new instances per second per account. - Traditional Workflows assume the workflow class is included in the deployment and statically configured in `wrangler.jsonc`. - That model breaks for: - Multi-tenant SaaS platforms - AI-generated tenant applications - Repository-specific CI/CD pipelines - Agents that create their own durable plans - In these systems, workflow code varies by tenant, agent, repository, or request, so a single statically bound class is insufficient. ## Dynamic Workflows - `@cloudflare/dynamic-workflows` is a roughly 300-line TypeScript library. - It introduces a Worker Loader that: - Loads each tenant’s code dynamically - Routes workflow creation to the appropriate tenant - Ensures later workflow execution returns to that tenant’s code - The Loader creates a dynamic Worker with: - A tenant-specific module - A `TenantWorkflow` entrypoint - A wrapped `WORKFLOWS` binding - The dynamic entrypoint is registered as the workflow class in `wrangler.jsonc`. - Tenant code remains ordinary Cloudflare Workflows code and does not need to know it is being dynamically dispatched. ## Tenant Workflow Behavior - Tenants can use the normal Workflow APIs, including: - `env.WORKFLOWS.create(...)` - Workflow IDs and `.status()` - `.pause()` - Retries and durable steps - `step.sleep('24 hours')` - `step.waitForEvent()` - A tenant can define a standard `WorkflowEntrypoint` with a `run(event, step)` method. - The library’s primary responsibility is preserving the association between a workflow instance and the tenant implementation when the workflow resumes later. ## Three-Layer Execution Model - Dynamic Workflows consists of three layers: - The Cloudflare Workflows engine - The platform’s Worker Loader - The tenant’s dynamically loaded Worker code - A request first enters the Loader, which identifies the tenant and routes execution to its dynamic code. - The workflow engine then persists the workflow state and later invokes `run(event, step)`. - The Loader resolves the correct tenant implementation when execution resumes, even after delays or failures. Dynamic Workflows provides the missing durable-execution counterpart to Cloudflare’s dynamic compute, storage, and source-control primitives. It is particularly suited to platforms where customers or agents generate workflow code at runtime while still requiring standard durable guarantees.

Read original(opens in new tab)
google3 min readCurated summary

Catalyzing scientific impact through global partnerships and open resources

Google Research argues that scientific breakthroughs have the greatest impact when their software, datasets, and methods are openly shared and responsibly maintained through global partnerships. Its open-science efforts span genomics, neuroscience, climate, biodiversity, and healthcare, reaching more than 250,000 researchers and developers. The post concludes that collaboration and open resources can turn individual discoveries into tools for broader scientific progress and real-world benefits. ## Partnerships Across the Scientific Ecosystem - Google Research works with organizations including UCSC’s Genomics Institute, Janelia Research Campus, ISTA, CSIRO, AIIMS, and the Centre for Population Genomics. - It supports major international initiatives such as: - The Human Pangenome Research Consortium - The Earth BioGenome Project - The NIH BRAIN Initiative - Google is also developing communities of practice for scientific developers, beginning in India, Korea, Japan, and Australia. ## Open-Source Tools and Datasets - **Genomics** - DeepVariant, DeepConsensus, and DeepPolisher support DNA analysis from sequencing through genome assembly. - These tools have helped process exomes and whole genomes from 2.5 million people. - **Neuroscience** - Flood-filling networks, Neuroglancer, and TensorStore enable analysis and visualization of petascale brain reconstructions. - The public H01 dataset contains 1.4 petabytes of human brain tissue data and has been accessed more than 200,000 times. - MICrONS provides a large wiring and functional map of the mouse visual cortex. - **Earth and Atmospheric Science** - Open Buildings contains 1.8 billion building detections across 58 million square kilometers. - Caravan supports large-scale hydrology and flood forecasting in 150 countries, covering roughly 2 billion people. - Groundsource includes 2.6 million historical urban flood events from more than 150 countries. - NeuralGCM is a differentiable hybrid atmospheric model, while FireBench supports wildfire research with high-resolution synthetic data. - **Biodiversity** - SpeciesNet classifies 2,498 animal categories in wildlife-camera images. - **Healthcare** - HAI-DEF provides open-weight medical foundation models, including MedGemma, with more than 4.8 million downloads. - Open Health Stack offers secure, offline-capable tools based on modern healthcare standards. - OHS-powered applications have reached more than 65 million people across over 10 countries. ## Scientific and Humanitarian Impact - **Genomics** - Work with UCSC improved pangenome references and reduced genetic-variant identification errors by 50%. - The research contributes to more representative genomic resources through the Human Pangenome Research Consortium. - **Weather and Agriculture** - The University of Chicago’s Human-Centered Weather Forecasts Initiative used NeuralGCM and ECMWF systems to predict India’s monsoon onset up to a month ahead. - Forecasts, including an unusual dry spell, were delivered by SMS to 38 million Indian farmers to support planting decisions. - **Disaster Response** - UNHCR and other organizations use Open Buildings to improve survey sampling for displaced populations. - The dataset also supports research into building vulnerability to sea-level rise in the Global South. - Sunbird AI uses the data to assess energy needs in urban and rural communities. - **Neuroscience and Medicine** - Johns Hopkins researchers used the H01 brain dataset to identify a possible new form of neuronal communication, suggesting that current models of brain organization may be incomplete. - The finding could have implications for understanding conditions such as Alzheimer’s disease. - Google also partnered with Stanford Medicine and UCSC to accelerate genome analysis in urgent cases of suspected genetic disease. ## Practical Conclusion The post presents open-source scientific infrastructure, accessible datasets, and cross-border partnerships as essential to accelerating discovery. Researchers and institutions can maximize impact by sharing reproducible tools, maintaining resources collaboratively, and applying them to urgent global challenges.

Read original(opens in new tab)
github2 min readCurated summary

GitHub Copilot CLI for Beginners: Interactive v. non-interactive mode

GitHub Copilot CLI offers two ways to work from the terminal: interactive mode for ongoing, collaborative sessions and non-interactive mode for quick, one-off prompts. The article recommends choosing between them based on whether you need iterative exploration or a fast answer within an existing shell workflow. Previous sessions can also be resumed in either mode. ## Interactive Mode for Collaborative Work - Start it by running `copilot`. - It is the default mode and provides a chat-like, back-and-forth experience. - Users can: - Ask questions about a project. - Review Copilot’s responses. - Ask follow-up questions. - Request actions, such as running a local server. - Copilot may request permission to trust the current folder because it needs to read or modify project files. - This mode is best for exploratory coding, troubleshooting, and tasks that require multiple steps. ## Non-Interactive Mode for Quick Prompts - Start it with `copilot -p "your prompt"`. - It produces a single response without opening a full conversational session. - Typical uses include: - Summarizing a repository. - Generating code snippets. - Running Copilot inside automated workflows. - It is designed to keep users in their normal terminal flow and is most useful when the required task is clear and narrowly defined. ## Resuming Previous Sessions - In interactive mode, enter `/resume` to select a previous session. - From the regular shell, use `copilot --resume` to open the session picker directly. - Resuming preserves the context of earlier conversations, making it easier to continue unfinished work. The practical choice is simple: use interactive mode for deeper, iterative collaboration and non-interactive mode for focused, one-shot requests.

Read original(opens in new tab)
cloudflare3 min readCurated summary

Post-quantum encryption for Cloudflare IPsec is generally available

Cloudflare has made post-quantum encryption for its IPsec service generally available, using hybrid ML-KEM alongside classical Diffie-Hellman. The implementation protects WAN traffic against “harvest-now-decrypt-later” attacks and interoperates with Cisco and Fortinet hardware already deployed by customers. Cloudflare argues that broadly adopted, software-based standards—not specialized quantum key distribution hardware—are essential for achieving post-quantum security at Internet scale. ## Cloudflare IPsec and WAN Connectivity - Cloudflare IPsec is a WAN Network-as-a-Service connecting: - Data centers - Branch offices - Cloud VPCs - Cloudflare One SASE environments - Encrypted IPsec tunnels run over Cloudflare’s global IP Anycast network. - Customers receive simplified configuration, high availability, automatic traffic rerouting, and global network scale. ## Hybrid ML-KEM for IPsec - The new implementation uses hybrid ML-KEM, standardized as FIPS 203. - It addresses harvest-now-decrypt-later attacks, in which attackers collect encrypted traffic today and decrypt it once quantum computers can break current public-key cryptography. - ML-KEM is designed to run in software on standard processors and requires neither specialized hardware nor dedicated physical links. - The IETF draft `draft-ietf-ipsecme-ikev2-mlkem` combines: - A classical Diffie-Hellman exchange - A second ML-KEM exchange encrypted using keys derived from the first - Key material from both exchanges mixed into session keys for IPsec ESP traffic ## Interoperability with Network Hardware - Cloudflare initially tested its implementation against the strongSwan reference implementation. - General availability now includes interoperability testing with: - Cisco 8000 Series Secure Routers running version 26.1.1 or later - Fortinet FortiOS 7.6.6 or later - These devices can establish post-quantum Cloudflare IPsec tunnels without requiring new specialized networking hardware. ## Why IPsec Lagged Behind TLS - Hybrid ML-KEM reached TLS production roughly four years before a corresponding IPsec specification. - Cloudflare enabled hybrid post-quantum TLS key agreement in 2022, and more than two-thirds of human-generated TLS traffic to Cloudflare is now protected this way. - IPsec standardization moved more slowly partly because of continued interest in Quantum Key Distribution (QKD). - Cloudflare criticizes QKD as unsuitable for Internet-scale deployment because it: - Requires specialized hardware and dedicated physical links - Does not provide authentication - Has limited cross-vendor interoperability - The NSA, Germany’s BSI, and the UK’s NCSC have warned against relying solely on QKD. ## Standards and Compatibility Challenges - RFC 9370, published in 2023, allowed multiple parallel key exchanges with classical Diffie-Hellman but did not define the specific ciphersuites to use. - Some vendors introduced incompatible or non-NIST-standardized ciphersuites, creating “ciphersuite bloat.” - Cloudflare’s implementation does not currently interoperate with Palo Alto Networks’ earlier RFC 9370-based implementation. - The newer ML-KEM draft fills this gap by defining hybrid ML-KEM as a standardized exchange mechanism. - Cloudflare hopes continued industry convergence will eventually enable interoperability with additional vendors, including Palo Alto Networks. ## Remaining Post-Quantum Work - Hybrid ML-KEM currently protects key establishment and data confidentiality. - IPsec still needs standardized post-quantum authentication mechanisms to defend live systems against quantum-enabled active attackers. - Cloudflare’s broader goal is full post-quantum security by 2029. Cloudflare recommends prioritizing interoperable, software-based post-quantum cryptography over niche QKD deployments. Organizations using supported Cisco or Fortinet branch hardware can begin protecting IPsec WAN traffic against future quantum decryption threats now.

Read original(opens in new tab)
cloudflare3 min readCurated summary

Agents can now create Cloudflare accounts, buy domains, and deploy

Agents can now take an application from development to production by creating Cloudflare accounts, obtaining API tokens, purchasing domains, and deploying code. Cloudflare’s integration with Stripe Projects removes most manual setup while keeping humans involved for permissions, terms acceptance, and payment approvals. The underlying protocol combines service discovery, authorization, and tokenized payments so agents can provision infrastructure on a user’s behalf. ## Zero-to-production deployment - Users install the Stripe CLI, authenticate, and run: ```bash stripe projects init ``` - An agent can then build an application and deploy it to a new domain. - If no Cloudflare account exists, one is provisioned automatically. - If an account already exists, the user authorizes access through OAuth. - The agent can: - Create a Cloudflare account - Obtain an API token - Register a domain - Deploy the application to production - Humans are prompted only when approval, terms acceptance, or payment setup is required. ## The protocol: discovery, authorization, and payment - **Discovery:** Agents query a catalog of available provider services and select the resources needed for the user’s request. - **Authorization:** The orchestrating platform verifies the user’s identity and enables providers to create accounts, connect existing accounts, and issue credentials securely. - **Payment:** Tokenized payment credentials let providers charge the user without exposing raw card details to the agent. - The approach builds on OAuth, OIDC, and payment-tokenization standards. ## Service discovery through a catalog - Agents can inspect available services with: ```bash stripe projects catalog ``` - They can select Cloudflare Registrar with: ```bash stripe projects add cloudflare/registrar:domain ``` - Providers expose service catalogs through REST APIs returning JSON. - This gives agents the context to choose appropriate products without requiring users to know which provider offers them. ## Automatic account creation and authorization - Stripe acts as the identity provider and attests to the user’s identity. - Cloudflare creates a new account automatically when the user has none. - Credentials are securely stored by the Stripe Projects CLI but made available to the agent for authenticated Cloudflare API requests. - Existing Cloudflare users authorize the integration through a conventional OAuth flow. ## Controlled agent spending - Agents never receive the user’s raw credit card information. - Stripe supplies Cloudflare with a payment token for subscriptions and purchases. - Spending is initially capped at $100 per month per provider. - Users can raise the limit and configure Cloudflare Budget Alerts as needed. ## Broader platform integration - The protocol is not limited to Stripe Projects. - Any platform with signed-in users can act as the orchestrator and integrate with Cloudflare. - This enables coding-agent platforms to let users deploy directly to production without requiring separate dashboard logins, token copying, or manual account setup. - Cloudflare is also enhancing the experience through its Code Mode MCP server and Agent Skills. Cloudflare and Stripe’s integration makes infrastructure provisioning an agent-driven workflow while retaining safeguards around identity, consent, and spending. For platforms building coding agents, adopting the protocol could provide a frictionless path from generated code to a live, paid production deployment.

Read original(opens in new tab)
grammarly2 min readCurated summary

Educator of the Year

Grammarly’s inaugural Educator of the Year Award honors teachers nominated directly by their students. The first winner, Dr. Humberto López Castillo of the University of Central Florida, is recognized for teaching precise, accessible communication and applying it to public health, technology, and community engagement. His approach combines audience-aware writing, responsible AI use, and hands-on research. ## Student-Led Recognition - Students nominate educators through short videos describing their impact on academic and professional development. - UCF student Vardhan Avaradi nominated Dr. López Castillo for encouraging students to make their language “precise yet accessible.” - López Castillo is a pediatrician, public health researcher, translator, and four-language polyglot from Panama. - His teaching emphasizes collaboration and the connection between individual health and broader communities. ## Communicating With Different Audiences - Students translate complex public health topics for audiences outside academia. - Assignments have included: - Storybooks about mosquitoes for kindergarteners - Monopoly-style games about living with HIV - Rap songs explaining tuberculosis - Podcasts that personalize epidemiology - His medical experience informs this approach: communication must change depending on whether the audience is a child, parent, or professional researcher. ## AI Requires Human Judgment - López Castillo permits students to use AI for drafting but expects them to verify and critically evaluate its output. - When AI-generated citations referenced nonexistent research, he treated the error as a lesson rather than a punishment. - He compares AI to a calculator: useful and powerful, but dependent on the judgment of the person using it. - He and Vardhan are developing a machine learning project using the NIH All of Us dataset, which contains nearly one million de-identified health records. - Their research explores using AI to classify populations and predict health risks. ## Preparing Students for Broader Impact - Students leave with stronger writing, critical-thinking, collaboration, and communication skills. - López Castillo’s teaching focuses not just on adopting new tools, but on using them responsibly and communicating with purpose. - His students learn to reach people beyond academic audiences while keeping human needs at the center of technology and research. The post’s central recommendation is to pair emerging technologies with critical thinking, audience awareness, and a strong sense of social responsibility.

Read original(opens in new tab)
line4 min readCurated summary

ID-JAG, a next-generation standard candidate for solving authentication challenges in the AI era

ID-JAG extends enterprise SSO trust to API access between AI agents, applications, and services. It uses an enterprise IdP to centrally evaluate permissions and issue a signed JWT that can be exchanged for a resource-specific access token. This can reduce consent prompts, improve auditing, and limit token sprawl, but organizations should adopt it cautiously while the specification remains an Internet-Draft. ## The Authentication Challenge in the AI Era - AI agents increasingly perform real work, including: - Searching systems - Querying databases - Sending messages - Creating tickets - As the number of connected services grows, authentication and authorization become more complex. - Poorly coordinated integrations can turn AI from a productivity tool into an operational bottleneck. - ID-JAG is being discussed by the IETF OAuth Working Group as a potential solution. ## What ID-JAG Is - ID-JAG, or Identity Assertion JWT Authorization Grant, extends the enterprise IdP’s SSO trust relationship to API access. - The IdP centrally determines: - Which application or agent may access an API - Which user or identity it acts for - Which scopes or permissions are allowed - It combines: - OAuth 2.0 Token Exchange (RFC 8693) - JWT Profile for OAuth 2.0 Authorization Grants (RFC 7523) - The IdP issues a cryptographically verifiable JWT as an “introduction” or authorization assertion. - The target authorization server validates that assertion and issues the final access token. ## The ID-JAG Participants and Flow The model involves four main parties: - **Requesting Agent:** An AI agent or application calling another service’s API - **Enterprise IdP:** Provides SSO and enforces centralized organizational policies - **Authorization Server:** Issues tokens for the target application - **Resource Server:** Hosts the API being accessed The basic five-step flow is: 1. The user signs in to the requesting agent, which obtains an ID token from the IdP. 2. The agent presents the ID token to the IdP and requests an ID-JAG through token exchange. 3. The IdP evaluates organizational policy and issues the ID-JAG if access is allowed. 4. The agent presents the ID-JAG to the target authorization server and receives an access token. 5. The agent uses the access token to call the resource server. The key architectural shift is that authorization decisions move from isolated agent-to-service relationships toward a centrally governed relationship between the enterprise IdP and target authorization servers. ## Benefits for User Experience and Auditing - Centralized IdP policies can reduce repeated consent screens. - This is especially useful when AI agents connect to many tools and services. - ID-JAG claims can record important context, such as: - The user whose authority is being delegated (`sub`) - The requesting agent (`client_id`) - The target authorization server (`aud`) - Approved scopes (`scp`) - Issuer, issue time, expiration, and unique token ID - Centralized issuance logs provide a clearer view of service-to-service relationships. - Security teams can more easily determine which agent accessed which service, on whose behalf, and with what permissions. - The same records can support incident investigation, compliance audits, and accountability. ## Centralized Control and Reduced Token Sprawl - The IdP can help detect and control unauthorized “shadow AI” integrations. - It can evaluate every token exchange using consistent organizational policies. - Requested scopes can be narrowed or overridden according to enterprise security requirements. - Blocking future access can be handled centrally instead of by changing policies across every endpoint. - ID-JAG may reduce token sprawl by avoiding additional long-lived refresh tokens. - The draft recommends that resource authorization servers generally not issue refresh tokens when an ID-JAG is exchanged. - Agents can instead submit a new ID-JAG to obtain another access token, replacing scattered API keys, service credentials, and refresh tokens with dynamic, policy-based trust. ## Adoption Requirements and Risks - ID-JAG is still an IETF Internet-Draft, not a finalized RFC. - Its behavior may change, so systems should avoid tightly coupling their core architecture to the current draft. - Before implementation, organizations need to verify that: - The requesting agent is registered as an OAuth client with both the enterprise IdP and the target authorization server. - Explicit trust relationships exist between the IdP and agent, and between the IdP and authorization server. - The IdP has pre-authorized the agent to act on users’ behalf for the relevant services and scopes. - Deployment also requires coordinated support from agents, enterprise IdPs, authorization servers, and resource servers. Organizations should treat ID-JAG as a promising architectural direction for governing AI-agent access, while isolating its implementation behind adaptable interfaces until the standard stabilizes. Pilot deployments should focus on centralized policy enforcement, detailed audit logging, strict scope control, and minimizing long-lived credentials.

Read original(opens in new tab)
figma2 min readCurated summary

Workflow Lab: Expanding the Canvas with Figma MCP | Figma Blog

Figma’s workflow demonstrates how the Figma MCP server can reconnect design and implementation as features evolve. By reading coded states and generating editable frames on the canvas, an agent exposes product behavior that was invisible in the original design. This lets designers improve real edge cases and compare the shipped experience with design intent earlier. ## The problem: Code creates new product states - Astra, a fictional AI video platform, ships features rapidly with agentic coding tools. - An initial export flow covered sequence selection, format choice, settings confirmation, and export. - As development progressed, additional states appeared: - Encoding errors - Rendering and loading progress - Empty selections - Unsupported formats - These states were not necessarily design oversights; they emerged from real code and data. - When the canvas represents only the initial flow, designers cannot fully address the experience users will encounter. ## Expanding the canvas with Figma MCP - The Figma MCP server allows an agent to read implementation details and write results to the Figma canvas. - Using `use_figma`, the agent identifies coded states and creates editable frames using the team’s design-system components. - Astra’s canvas expands from four original frames to fourteen frames representing the broader product reality. - This replaces a slower task-and-ticket feedback loop with a direct conversation between design, code, and the agent. ## Designing better edge cases - The designer can immediately work on states that previously remained hidden: - Adds recovery guidance to the encoding error state. - Enhances the render loading state with progress information and an estimated completion time. - Adds copy and personality to the empty-selection state to encourage feature adoption. - Designers spend less time discovering missing requirements and more time shaping actual product behavior. - The canvas becomes a shared workspace for reviewing the full experience, not merely documenting the initial concept. ## Comparing design and implementation - The workflow also places the coded version beside the original Figma design for visual comparison. - A findings panel surfaces discrepancies by severity. - Example differences include: - A larger modal title - An additional “Post share link” button - A removed settings-panel surface - A demoted settings header The practical recommendation is to use Figma MCP as an ongoing design-code feedback loop: bring real implementation states onto the canvas, refine them with design expertise, and use visual comparisons to catch drift before it becomes part of the shipped product.

Read original(opens in new tab)
gitlab3 min readCurated summary

Automate detection testing with GitLab CI/CD and Duo

GitLab’s WATCH framework continuously tests whether security detections still work in real conditions, rather than only verifying that detection rules deploy successfully. It runs simulated attacks in staging, checks alert propagation through logging, SIEM, and SOAR systems, and reports failures automatically. The framework uses GitLab CI/CD to schedule randomized tests, correlate expected alerts, and publish detection-health results. ## The Detection-Validation Gap - Security detections can silently fail because of: - Log schema changes - SIEM updates - Ingestion or pipeline misconfigurations - Other changes between the log source and alerting systems - Reinjecting synthetic logs into a SIEM can test rule logic, but it does not validate real-world behavior or the log-ingestion path. - GitLab’s detections-as-code pipelines confirm that rules can be created and deployed, but not that they fire when the targeted activity occurs. - WATCH fills this gap by validating detections end to end. ## WATCH’s Testing Lifecycle - **Scheduling:** A weekly GitLab CI/CD pipeline discovers active tests and assigns them randomized execution times. - **Heads-up notification:** WATCH creates a dedicated “WATCH Heads Up” SOAR record containing the detections expected to fire. - **Execution:** Scripts perform simulated malicious actions in staging, such as resetting an administrator password or making suspicious API calls. - **Detection:** Activity logs flow through ingestion into the SIEM, where detection rules process them. - **Correlation:** SOAR matches alerts to registered WATCH tests using: - The time window between execution and alerting - Actor identity, such as an IP address or username - The detection rule ID - **Verification:** A follow-up job confirms that all expected detections fired, updates detection metadata, and publishes results to a GitLab Pages dashboard. - Failed tests generate notifications in the team’s Slack channel. - Correlation prevents test alerts from being escalated as genuine incidents while still validating the complete alerting pipeline. ## GitLab CI/CD Implementation WATCH is organized into three pipeline stages: - **`schedule_pipelines`:** - Runs weekly. - Finds active tests and groups them into scheduled pipelines. - Passes the selected tests through the `TESTS_TO_RUN` variable. - **`run_tests`:** - Executes the assigned attack simulations. - Saves execution results in `detection_status.json`. - Records SOAR identifiers needed for later alert correlation. - **`pages`:** - Queries the SOAR to verify alert generation and routing. - Updates `detection_status.json` with test results. - Deploys the latest status data and dashboard assets to GitLab Pages. The example configuration uses Python 3.12, pipeline inputs to enable weekly scheduling or dashboard updates, conditional `rules`, and GitLab Pages artifacts. Scheduled execution is randomized to avoid predictable test patterns and to expose timing-related problems. ## Practical Recommendation Organizations with critical security detections should add continuous behavioral testing alongside detections-as-code validation. A framework like WATCH can provide earlier warning of broken ingestion, rules, or routing while reducing the cost and generic limitations of commercial breach-and-attack simulation tools.

Read original(opens in new tab)
naver1 min readCurated summary

A Non-Developer’s AI Collaboration Challenge — 9 Days of Trying to Measure Productivity and Ending Up Launching a Server

The content is not a substantive tech blog post. It consists of a “Hello world” message and navigation links to NAVER’s developer resources, news, events, open-source projects, and startup program. ## Page Contents - Links to: - D2 News - About D2 - NAVER Developers - DEVIEW - OpenSource - D2 STARTUP FACTORY - Footer copyright notice: - © NAVER Corp. All Rights Reserved. There are no technical explanations, arguments, or conclusions to summarize.

Read original(opens in new tab)
stripe4 min readCurated summary

Everything we announced at Sessions 2026

Stripe announced 288 products and features at Stripe Sessions, focused on making payments more programmable, expanding the protection offered by its global network, and supporting AI-driven commerce. Major launches cover agentic payments, checkout optimization, fraud prevention, in-person payments, and merchant-of-record services. The overall direction is toward infrastructure that supports automated transactions, global commerce, and new usage-based business models. ## Agentic Commerce and Payments - The Agentic Commerce Suite lets businesses upload product catalogs and control how AI agents access them through the Stripe Dashboard. - Platforms can make connected accounts “agent-ready,” with discovery, checkout, payments, and fraud detection handled through one integration. - Partnerships with Meta and Google enable: - Native checkout inside Facebook ads. - Purchases through Google AI Mode and the Gemini app using the Universal Commerce Protocol. - The Machine Payments Protocol supports agent-driven microtransactions, recurring payments, and other programmatic transactions. - Agents can pay using stablecoins or fiat payment methods, including cards, Klarna, and Affirm, through Shared Payment Tokens and the PaymentIntents API. ## Link and Checkout Improvements - Businesses can authorize agents to pay through Link’s agent wallet while retaining spending controls and purchase visibility. - Link adds Pix and stablecoin support for US businesses, with UPI support in India previewed. - A new Dashboard view shows Link’s effect on conversion, authorization rates, and payment costs. - Checkout Studio will use AI assistance, transaction replay, A/B testing, and recommendations to configure and improve checkouts. - Stripe previewed an embedded Checkout form for interfaces such as sidebars, chat boxes, and modals. - More payment methods now support subscriptions, localized currencies, and cross-border payments, including Pix, UPI, Bizum, BLIK, Pay by Bank, and TWINT. - Adaptive Pricing AI can detect a customer’s preferred currency and localize subscription prices. ## Stripe Terminal and Managed Payments - The Stripe Reader T600 includes an eight-inch screen and can run custom applications for loyalty programs and upselling. - Terminal expands to 15 additional markets and adds payment methods such as Alipay, Klarna, and UnionPay International. - Standalone mode will allow businesses to accept payments without building a point-of-sale system. - Stripe Managed Payments is now available to all digital businesses as a merchant-of-record solution, handling indirect tax compliance in more than 80 countries, fraud, disputes, and customer support. ## Payments Optimization and Intelligence - Businesses can A/B test Authorization Boost against their existing payment performance. - New AI optimizations, including Data Only authentication and PINless debit retries, reportedly increase acceptance rates by an average of 3.8% and reduce processing costs by up to 3.3%. - Stripe 3DS can now be used independently for payments processed by another provider. - The Dashboard assistant can investigate payment performance, identify root causes, and recommend actions using natural language. ## Expanded Fraud Protection with Radar Stripe’s Radar upgrades target newer forms of abuse, including token misuse, account fraud, trial abuse, and fraudulent AI-agent activity. - Free-trial abuse prevention identifies risky trials without unnecessarily blocking legitimate customers. - Radar Signals can detect fraudulent payments, predict disputes and early fraud warnings, identify pay-as-you-go abuse, and detect multi-account or account-sharing behavior. - New merchant signals assess risks such as merchant delinquency and suspicious websites using LLM-powered analysis. - Stripe Issuing authorization signals extend fraud prediction to cards issued by other banks, fintechs, and payment providers. - Radar protection now covers additional payment types, including bank debits, wallets, BNPL, and stablecoins. - Custom Radar models combine a company’s own data with Stripe’s network intelligence. - Improved Checkout interventions use targeted measures such as CAPTCHAs to reduce fraud with less impact on conversion. - Smart Disputes can recommend evidence such as tracking numbers and usage logs, while an evidence library stores reusable documents like terms and conditions. ## Revenue and AI-Native Business Models Stripe also began upgrading its Revenue suite for AI-focused businesses. The announced direction includes real-time metering, rating, alerting, streaming payments, dimensional pricing, new Billing customizations, and broader access to query-ready data. The supplied post ends before detailing these Revenue features. Stripe’s announcements point toward a unified platform for global, automated commerce: businesses can sell through agents, optimize payments with AI, extend fraud controls across payment networks, and support flexible pricing models. Companies building AI products or international digital businesses should evaluate the new agentic commerce, Radar, Checkout, and Managed Payments capabilities as they become available.

Read original(opens in new tab)