LectureRechercheRadarCadre d'investissement
Connexion / Inscription
ToutTechnologieProduitsInvestissementBourseAutres

Lecture

2026-11-0716 publications

Actualiser

Security firm reports bypassing ChatGPT 'Lockdown Mode' to access chat history; OpenAI patches flaw

Matériel
2026-11-07 00:05 GMT+8

Researchers from US cybersecurity firm Check Point Research (CPR) discovered a method to bypass OpenAI ChatGPT's 'Lockdown Mode', a feature designed to protect users from prompt injection attacks by restricting external connections and disabling certain functions. The researchers exploited a flaw in the nested sandboxed frames used for HTML previews within code blocks, allowing popups to escape sandbox restrictions and potentially access the entire chat history.

'Lockdown Mode' was originally designed to reduce the risk of sensitive data exposure via prompt injection by limiting features like live web browsing, Deep Research, Agent Mode, and file downloads. However, CPR noted that while ChatGPT intercepted direct attempts to open new windows, the underlying sandbox permissions still allowed popups to exist and escape. By creating nested frames, the researchers could access unmodified popup functions, bypassing all restrictions placed on the original HTML preview.

This vulnerability could lead not only to data theft but also to malware deployment, phishing attacks, or credential theft. The most dangerous scenario described was a 'zero-click' attack, where the popup appears without user interaction. CPR emphasized that 'AI security controls are only as strong as the wider application environment around them,' indicating that model-level security measures alone are insufficient and enterprises must consider the overall attack surface comprising applications, runtimes, and connectors.

OpenAI implemented additional safeguards server-side after receiving the disclosure to disable this workaround. Although the vulnerability has been patched, the incident serves as a reminder for users and organizations to remain vigilant about application-layer security boundaries when handling sensitive information with AI tools and to seek greater visibility into AI usage.

Sources :TechRadar

Recherche

Alibaba Cloud Engineering Team: Code Written Ten Times Faster, Why Delivery Cycle Only Shortened by 1.8 Days

Sujet · 阿里AI工程交付瓶颈Matériel
Vérifié 2026-11-07 16:07 GMT+8

For a complex feature, the typical team requires about 20 working days from requirement proposal to launch, with coding occupying only two days. Assuming an AI coding tool increases this speed tenfold, reducing two days to 0.2 days, the entire delivery cycle shortens from 20 days to just 18.2 days. In practice records published by the Alibaba Cloud engineering team in November 2026, this arithmetic places the issue on the table: accelerating code writing is not the bottleneck; rather, requirement discussions, solution confirmation, testing and verification, cross-module integration, and release preparation are the actual constraints. Once code is written faster, these preceding and following steps become even more conspicuous.

Their approach involves breaking down the work undertaken by different roles in the R&D process into 15 distinct Agents, which a Leader schedules according to task requirements. Each Agent possesses independent skills, tools, and context, with clear responsibilities: the Researcher understands requirements and the codebase while building a problem evidence graph; the Explorer identifies isomorphic implementations to form candidate solutions; the Spec structures goals, boundaries, and acceptance criteria; the Code Worker implements candidate solutions in independent branches and sessions; Test/Harness executes compilation, testing, and end-to-end verification; Judge/Verify independently selects the best candidate, performs semantic acceptance, and conducts adversarial review; and Deploy prepares the environment and executes release verification.

Two design choices within this architecture are considered most critical by the authors. First, implementation and verification must be completed by different Agents, ensuring that verification maintains an independent perspective—if the Agent writing the code also judges its own correctness, verification loses its meaning. Second, context across iterations must be preserved—subsequent Agents must be able to continue using information regarding what the previous Agent did, why it was done that way, and what was discovered during verification. If tests fail, the process returns to the original Code Session for continued fixes; if the solution direction is incorrect, Research and Explore are redone with failure evidence; if repeated attempts still do not converge, a Human Gate is triggered to request human intervention for judgment.

Beyond AgentCore, which handles execution, they established AgentLoop as an optimization plane. AgentLoop records the task completion process: which models and tools were called, where failures occurred, how many rounds of rework took place, and whether the final result met requirements. These Trace, Session, and Trajectory data undergo processing through Pipeline, Dataset, Evaluation, and Experiment stages, transforming into reproducible samples, comparable metrics, and repeatedly verifiable experiments. Optimization occurs in three ways: manual, where domain experts define good results, metrics, and evaluation Rubrics; semi-automatic, where the system generates optimization suggestions (identifying tasks consuming excessive Tokens, inefficient steps, or tools consistently reporting errors); and automatic, where experience repositories extract insights from Traces using the RAC method and dynamically inject them into Agents.

Sources :Alibaba Cloud Community

Recherche

AMD Releases InferaSim: Predicting LLM Serving Performance with Sparse Measurements to Cut Tuning Costs

Sujet · InferaSimMatériel
2026-11-06 08:00 GMT+8

US semiconductor company AMD released the open-source tool ROCm InferaSim on November 6, 2026, aiming to address the prohibitive costs of tuning Large Language Model (LLM) inference service configurations. Before deploying an LLM service, engineers must select parameters such as the inference engine, parallel layout, precision, and scheduler settings, generating thousands of candidate configurations. Traditional methods require hardware measurement for each configuration, with each trial tying up multi-GPU nodes for minutes. AMD stated that measuring every candidate in their search space would take approximately 25,000 GPU-hours, leading most teams to try only a few guesses and keep the best, while missed guesses result in extra GPU waste or failed latency targets.

The core idea behind InferaSim is "measure sparsely, transfer analytically." The tool separates parameters that change which kernels run (such as model, dtype, attention backend, graph mode, and speculative decoding) from those whose costs scale analytically (such as batch size, concurrency, context length, tensor-parallel width, and replica count). For the former, InferaSim performs one short measured run, called an "anchor," saved as a JSON file containing a batch sweep of measured prefill and decode step latencies plus a signature of what was running. For the latter, the tool performs fast analytical projections based on the anchor. Each projection takes under half a second on a single CPU core.

Internal tests on AMD's own Instinct MI355X GPUs showed that 11 anchors cost 9.1 GPU-hours and covered 226 configurations that took 204 GPU-hours to measure fully. This means GPU time is spent confirming a shortlist rather than exploring all possibilities. InferaSim can predict whether a recipe fits in HBM, the latency distribution under a given arrival process, the number of replicas needed for an SLO, and the best split between prefill and decode before any deployment exists.

The tool also introduces a discrete-event simulator (DES) to simulate Poisson arrivals, providing latency percentiles and queue wait times instead of just averages. Additionally, InferaSim plots the throughput-versus-interactivity Pareto frontier, helping teams find the configuration with the highest throughput per GPU at a given interactivity level. According to AMD's published paper and blog, InferaSim's predicted frontier kept all 10 measured-frontier configurations for GLM-5.2 and 11 of 12 for MiniMax-M3.

Developers can access the code via GitHub and install it on hosts supporting the ROCm software stack. InferaSim offers two modes: the default "anchored mode" uses matching anchors to calibrate the step model for absolute number predictions, while "simulate mode" is fully analytical and requires no anchor, suitable only for ranking candidates within one engine. This tool provides AI infrastructure teams with a more economical and efficient path for optimizing inference services.

Sources :ROCm Blogs

Recherche

Salesforce Architect Proposes Closed-Loop Testing Method: Using Immutable Snapshots to Prevent AI-Generated Code from Exhausting Transaction Budgets

Matériel
2026-11-06 02:54 GMT+8

When generating code on the Salesforce platform, AI agents face a problem not prominent in traditional development: they optimize for the immediate task rather than the overall resource budget of the transaction in which that task executes. Even if each feature passes tests individually, cumulative consumption may still breach platform hard limits during a seemingly harmless change.

In an article published on November 5, 2026, Sakthi Kuppusamy, Senior Technical Architect at Salesforce, describes this compounding pattern: Sprint 1 adds account validation logic, consuming 15% of the SOQL query limit; Sprint 2 adds data enrichment, rising to 32%; Sprint 3 adds related contact lookups, reaching 51%; Sprint 4 adds a duplicate check worth only 8% on its own, totaling 59%. No single change is problematic in isolation, but in traditional development, such accumulation unfolds over months, giving teams time to notice degradation, whereas agents can compress this timeline into a single afternoon of merged pull requests.

Kuppusamy's core argument is that governance limits are not platform constraints to be circumvented, but architectural contracts to be designed for from the start. To enforce this contract, he proposes a three-layer mechanism.

The first layer is the immutable snapshot class. Deploying a test utility class named GovernorLimitSnapshot (annotated @IsTest, so it does not count against the organization's Apex code size limit), the agent must consume this tool without modifying or redefining it. This class captures resource allocation and consumption before and after execution, centralizing threshold logic in one place to prevent agents from scattering assertions throughout the codebase.

The second layer is budget allocation per execution context. Synchronous transactions have a SOQL query limit of 100 and CPU time of 10,000 milliseconds; asynchronous transactions allow 200 queries and 60,000 milliseconds. However, different execution contexts should be allocated different proportions: Triggers (shared events) are recommended at 40% to 50%, because other triggers, flows, and validation rules exist within the same transaction; Service classes (single responsibility) at 60% to 70%; Queueable, Future, and Batch Apex (isolated contexts) at 80% to 85%; Scheduled Apex (lightweight orchestration) at 20% to 30%. These budgets are not additive—a service class called from a trigger draws from the trigger's budget and has no independent quota of its own.

The third layer is closed-loop feedback in CI/CD. When a test violates a threshold, the pipeline does not simply mark the build as failed; instead, it sends a structured prompt to the agent containing violation details, budget thresholds, and optimization hints. After the agent refactors and resubmits, if the second CI run still exceeds limits, the feedback includes the delta between attempts: what improved and which metric remains over budget. If the third push still fails, the pipeline halts the loop, blocks the merge, and opens a manual architect review task with the full run history. This three-strike boundary routes fundamental architectural issues (such as a feature that genuinely cannot fit into a synchronous transaction) to human decision-makers to determine whether to migrate logic to an asynchronous Queueable or adjust the transaction budget.

Sources :Salesforce

Recherche

Datadog Troubleshooting Prompt Cache Misses: Four Silent Code-Level Traps

Sujet · DatadogMatériel
2026-11-06 08:00 GMT+8

The AI applications team at Datadog encountered a counterintuitive phenomenon while investigating LLM costs: multiple internal applications had enabled prompt caching options, yet there were zero cache hits in actual requests. Each request contained over 180,000 input tokens, with single-request costs ranging from $0.74 to $0.82. Once caching took effect, the cost for the same task could drop to between $0.02 and $0.14. The gap was so significant that finding the cause seemed impossible.

Staff Engineer Bruno Volpato and his team recorded the complete troubleshooting process. Their methodology was to first use Cloud Cost Management to view overall spending, then use Agent Observability to trace down to individual model calls, and finally compare the differences between the first call and subsequent calls within the same task. An agent might call the model multiple times to complete one task, repeating system instructions, tool definitions, and conversation history each time. If caching worked correctly, subsequent calls should read these repeated contents from the cache.

The investigation revealed four categories of silent failure modes. The first category involved mutable content mixed into reusable prefixes. A chat service concatenated system instructions with current time, organization details, feature flags, and incident context. Prompt caching relies on byte-by-byte matching of request prefixes—if a timestamp appears before the instructions, even if the subsequent instructions are identical, the cache cannot hit. Their fix was to place stable instructions first and request-specific details last, using cache boundary markers to denote the end of the reusable portion where supported.

The second category was non-deterministic ordering of tool lists. That chat service built its tool list in Go, and Go's map iteration does not guarantee order. One request might send tools in the order A, B, C, while the next sends them as B, A, C. Since tool descriptions are part of the cached prefix, a change in sequence breaks the match. The patch was simple: sort by name before building the list. The team also added a test that inserts the same tools into maps in different orders to verify the resulting list is consistent.

The third category was caching options not being passed to the actual request. One application enabled an option called WithPromptCaching, but inspection of requests sent to Anthropic revealed that this option only added a beta header; the request body lacked the control parameters telling the provider what to cache. Another application was more direct: the SDK's caching option was simply not passed to the component preparing the provider request.

The fourth category was API routes that did not support caching. Datadog's gateway can route through Anthropic's native Messages API or a compatibility endpoint formatted for OpenAI. The native route supports cache reads, while the compatibility route has none. Anthropic's documentation confirms that the compatibility endpoint does not support prompt caching. Migrating applications to the native API became a potential fix path, but the team needed to verify that message roles, tool calling, and streaming responses still functioned correctly under the new route before recommending it.

Sources :Datadog

Recherche

NVIDIA Technical Blog Details FLUX 3 Image Klein Blackwell Inference Optimization Methods, Single-GPU Speedup Up to 4.45x

Matériel
2026-11-07 06:20 GMT+8

Generating high-resolution images with diffusion models requires dozens of sequential forward passes through a model with billions of parameters, where the computational cost of attention increases with resolution. The NVIDIA Technical Blog recently released a tutorial addressing inference latency for FLUX 3 Image Klein on Blackwell GPUs, proposing a layered optimization scheme. Each layer targets different computational bottlenecks in the pipeline; when stacked, these optimizations compress the text-to-image latency for the Base model at 2048×2048 resolution from 22.36 seconds to 6.46 seconds, and reduce image-to-image latency from 54.64 seconds to 12.28 seconds on a single B200 GPU.

The inference pipeline for FLUX 3 Image Klein consists of three components: Qwen3-VL-4B-Instruct handles text condition encoding, the Diffusion Transformer (DiT) executes denoising iterations, and an autoencoder decodes latent variables into pixel images. At 2048×2048 resolution, the denoising phase accounts for 96.8% of the total latency for the Base model, with attention computation occupying approximately 60% of the DiT GPU kernel time. Consequently, optimization focuses on two core bottlenecks: GEMM matrix multiplication throughput and attention computational costs.

The first layer combines NVFP4 quantization with PrimsTS fused GEMM kernels. NVIDIA states that NVFP4 delivers up to 1.62x faster text-to-image generation on a single B200 compared to BF16. The PrimsTS kernel fuses GEMM with SwiGLU, QKV projection, and RoPE rotary position encoding epilogues, reducing kernel launch overhead. The second layer addresses the attention bottleneck: regarding quantized attention, VC-Attention FP8 (with a repair budget ρ=0.005) provides a 1.18x speedup with an LPIPS score of 0.086; regarding sparse attention, Sol-Attention (τ=1.0, 12 initial dense steps) yields a 1.30x denoising speedup but raises the LPIPS to 0.151. The third layer, Cache-DiT, reuses intermediate Transformer outputs across adjacent denoising steps, nearly halving the Base latency (1.94x speedup) at a threshold of 0.24, with only an LPIPS increase of 0.033.

Multi-GPU scaling utilizes CFG branch separation combined with Ulysses sequence parallelism: on eight B200 GPUs, the median text-to-image latency for the Base model drops from 14.90 seconds to 3.00 seconds, achieving a 6.01x denoising speedup. However, the article notes that for the distilled Klein variant, approximately half of the generation time on eight cards falls outside the denoising phase (including text encoding, decoding, and post-processing), which limits end-to-end gains.

It is important to emphasize that all data are self-reported results from NVIDIA under specific conditions: hardware (B200), resolution (2048×2048), and model configuration, with no third-party independent replication yet available. The quality trade-offs for each optimization stage are transparently presented via LPIPS scores, allowing developers to select configuration combinations based on their specific latency and fidelity requirements.

Sources :NVIDIA Technical Blog

Recherche

Databricks Proposes OpenSharing: Replacing Customer Data Replication Pipelines with In-Place Reads

Sujet · OpenSharingMatériel
2026-11-07 06:10 GMT+8

Data engineers have likely experienced this scenario: a client drops a file into a designated directory via SFTP every week, and your job scripts pull, parse, and load it. The first client is no problem; by the fifth, format deviations appear; by the twentieth, your pipeline has become twenty independent mini-systems, each with its own quirks, failure modes, and backfill logic.

In a blog post, Databricks engineering team members Jordan, Soldo, Nikhil, and Tallam break this problem down into three layers of hidden costs: pipeline maintenance (each client has unique failure points), incremental tracking (you must manually remember where processing left off; if bookkeeping drifts, you duplicate or miss records), and backfill dependencies (when a bug requires reprocessing months of data, you must ask the client to re-export it).

Their proposed alternative is OpenSharing, a protocol based on open table formats such as Delta Lake and Iceberg. The core idea can be summarized in one sentence: do not copy; read in place.

The specific mechanism works as follows: the client already maintains a table, and you read that table directly via the OpenSharing protocol instead of having the client export files to you. When your pipeline runs, it reads the table's Change Data Feed, identifying which records have been created, deleted, or updated. This means you no longer need to maintain a separate table to track processing progress—the pipeline automatically manages this checkpoint.

In the traditional model, clients must build and maintain an export pipeline to feed you data—complete with its own scheduling, formatting, and failure modes. OpenSharing simplifies this to a single authorization operation: granting you read access to a table the client already maintains.

Regarding impact on system performance, the authors explain that you are reading table files from cloud storage using your own compute resources, rather than querying the client's database, so it does not slow down the client's systems.

The authors also emphasize the protocol's openness: because it is built on open table formats, the reader does not need to use the Databricks platform.

It should be noted that this is a product design explanation from Databricks, without accompanying customer migration data, performance benchmarks, or quantitative comparisons with existing solutions. The claimed benefits—eliminating pipeline maintenance, turning backfills into queries, and saving storage for both parties—are expected outcomes of the architecture design, rather than verified production metrics.

For teams maintaining multiple client data pipelines, the value of this article lies in providing a clear architectural comparison: the cost structure of the traditional model (linearly growing maintenance burden) versus the cost structure of the in-place read model (fixed protocol + table-builtin version history). Whether migration is worthwhile depends on an honest assessment of your own pipeline complexity.

Sources :Databricks

Recherche

Taxbit Engineering Practice: Retrieval and Security Strategies for Building Reliable AI Assistants in Regulated Industries

Sujet · Taxbit AI助手Matériel
2026-11-07 00:49 GMT+8

Taxbit is a digital asset tax and accounting compliance platform founded in 2018, serving enterprise clients such as exchanges, payment services, and brokers. Its newly launched AI assistant, Taxbit Assist, is embedded in the product dashboard, helping compliance teams obtain reliable answers in regulated environments. This practice demonstrates how specific engineering measures can ensure the credibility and security of answers when building AI assistants in sensitive fields.

When building Taxbit Assist, the team faced four core constraints: answers must be grounded and citable; the assistant must possess role and organization awareness to avoid guiding users into workflows they do not have permission to access; there must be a strict distinction between product documentation and tax advice; and regional data residency requirements must be supported. To meet these requirements, the team selected Amazon Bedrock AgentCore as the underlying platform, leveraging its managed agent runtime, built-in memory capabilities, and session isolation features, thereby allowing them to focus primarily on retrieval and security work.

Improvements in retrieval quality were mainly due to two key engineering practices. The first is the context chunking strategy: the team adopted semantic chunking and added the title and lead paragraph of the document to which each chunk belongs before every chunk via custom transformation hooks, ensuring that each chunk carries information about its scope. This change proved to be the most impactful retrieval optimization, effectively preventing misleading results caused by chunks losing their context. The second is retrieval process optimization: at query time, the system first obtains a large number of candidate passages through vector search, then uses a reranking model for fine-grained ranking, and limits the number of chunks returned per source document, thereby balancing recall and precision.

In terms of security and data protection, Taxbit has implemented a series of strict measures. The knowledge base does not contain any tenant-specific content, only public documentation, code-generated product references, and manually curated articles. Identity verification information does not pass through the model but is bound directly to tool calls by trusted services, preventing prompt injection attacks. Additionally, the system uses Amazon Bedrock Guardrails to de-identify personally identifiable information (PII) in input messages and employs geography-aware inference profiles to ensure data is processed within designated regions, meeting data residency requirements in the European Union and the United States.

To continuously guarantee answer quality, Taxbit deployed a multi-layered evaluation mechanism in its production environment. The system samples 10% of real-time sessions and uses an LLM-as-a-judge evaluator to score answers across six dimensions, including usefulness and coherence. Meanwhile, a foundation model classifier detects whether answers exhibit tax advice drift, with a false positive rate close to zero, significantly lower than the approximately 25% rate of traditional topic filters. Corrected content reviewed by humans is written into the curated prefix of the knowledge base and triggers incremental indexing jobs, allowing expert corrections to take effect within minutes.

Sources :Amazon Web Services

Recherche

Tübingen University Researchers: AI Providing a Fitted Model Is Just an Answer; Providing the Model Distribution Is Understanding

Sujet · 图宾根AI模型分布论Matériel
2026-11-06 08:00 GMT+8

In 1951, Cambridge University’s computer went out of action for six months. Physiologist Andrew Huxley was forced to crank a hand-operated mechanical calculator, spending over three weeks solving equations he and Alan Hodgkin had just established—equations describing the action potentials of squid nerve cells. To make the curve fit experimental data, they found they had to raise a certain variable to the fourth power. At the time, they did not know why; they only knew that simpler versions (such as the third power) did not fit well enough, while higher powers might fit slightly better but were not worth the extra complexity. They cautiously proposed a hypothesis: perhaps four charged particles on the membrane must be in place simultaneously for the gate to open.

Decades later, another team found the structure of the relevant potassium ion channel protein and discovered that it indeed consists of four identical subunits arranged around a central pore. The model fitted the data in 1951, yet it helped predict the structure of a protein it had never been fitted to.

In this guest article published in November 2026, Jakob Macke, Daniel Gedon, and Stefan Wahl of the ELLIS Institute Tübingen Branch and the University of Tübingen use this story as a starting point to propose a core argument about AI-assisted scientific modeling: simply knowing that the fourth power fits the data is not enough; what matters is knowing that simpler versions do not work. An AI system that merely hands you a model can give you an answer, but it cannot give you understanding.

They divide scientific modeling into three steps: building the model (deciding the shape and components of the equation), constraining the model (tuning parameters to fit measured data), and interpreting the model (asking what the model says about the real system). The Hodgkin-Huxley four-particle hypothesis held up precisely because they ruled out lower-power alternatives. If the third power could also fit the data, there would be no reason to believe the gating mechanism involved multiple moving parts.

The article argues that AI has made the most progress in the constraint step. Traditional methods provide only one set of optimal parameters, hiding other combinations that could also fit the data. Simulation-Based Inference (SBI), through extensive random sampling and neural network training, returns a complete probability distribution of parameters, allowing researchers to see which parameters are tightly constrained by data, which remain ambiguous, and where more experiments are needed. This method has been applied to the Hodgkin-Huxley model itself, as well as to neutron star collision localization, cosmology, and structural biology.

In the building step, LLM agents can now write code to generate candidate models, run them, constrain parameters, compare outputs, and modify equation forms in a loop until the fit is good enough. However, the article points out a key issue: running an agent twice on the same data may return two different but equally good models. Returning only one of them is like returning only one set of optimal parameters—it hides other possibilities. Therefore, the authors advocate treating model building similarly to model constraining: requiring the AI system to return the range of all models that can reasonably explain the data, rather than a single best fit.

Sources :anthropic.com

Recherche

AWS Logistics Team: Adding New Datasets Requires Only a JSON File, AI Agent Auto-Discovery Without Redeployment

Matériel
2026-11-07 01:13 GMT+8

When enterprise AI Agents need access to data lakes, the most common practice is for each Agent to embed its own SQL generation logic, schema knowledge, and connection handling. When datasets change, every Agent must be patched individually; permissions are scattered with no unified audit point; onboarding a new table typically requires days of custom development. Under the pressure of managing thousands of datasets while multiple teams build their own AI assistants, the engineering team supporting Amazon’s North America Sort Center (NASC) network chose a different path: centralizing data access capabilities into a single stateless MCP server, letting Agents focus solely on reasoning and orchestration without worrying about how underlying data is accessed.

The core design decision of this server is to decouple the tool layer from the agent layer. Agents evolve rapidly, but data access patterns should outlive any single Agent implementation. The specific approach is as follows: each table corresponds to a JSON metadata file recording the database service name, table name, business description, column-level semantics (including type, natural language explanation, and sample values), load type, and refresh frequency. After this file is picked up by the pipeline, vector embeddings are generated using Amazon Titan Text Embeddings and indexed into Amazon Bedrock Knowledge Bases. Once indexing is complete, all connected Agents can discover and query that table without manually rebuilding indexes or restarting the server.

There is an easily overlooked but actually critical field in the metadata file: business_description_for_the_table. It does not just write the business meaning of the table, but also carries engine-specific query hints. For example, the example in the text writes:

In Athena SQL, always use date() to wrap string literals when comparing against timestamp columns.

Such hints directly reduce the number of validation failures after SQL generation. Column-level sample values are equally important—if the Agent sees that the sample value for warehouse_id is FC-EAST-07 rather than East region facility, the generated WHERE clause will use the correct format.

The architecture is divided into four layers, each independently scalable: the client layer handles authentication and session state (Amazon Cognito validates JWTs, DynamoDB stores conversation history); the MCP server layer performs query analysis, tool selection, and result orchestration (FastMCP framework, driven by Amazon Bedrock); the tool layer connects to Athena and Redshift to execute SQL and to Knowledge Bases for semantic retrieval; the knowledge base refresh layer is responsible for discovering and indexing metadata files. Fargate tasks are stateless, with session state persisted in DynamoDB, so tasks can be replaced or scaled at any time without losing context.

The team also introduced an optional context mapping mechanism: specifying which tables a particular application should focus on. When context limits the table scope, the MCP server searches only those tables in the metadata catalog, reducing noise and improving SQL generation accuracy, while keeping end-to-end latency within the 15 to 20 seconds range tested by the team. When no context is specified, the Agent searches all indexed tables.

Sources :Amazon Web Services

Recherche

Amazon Quick Team Proposes Four-Question Classification for Agentic Primitives: Distinguishing Skills from Workflows via Confidence Contracts

Matériel
2026-11-07 01:34 GMT+8

When building agent systems, a persistent question arises: how should a given user request be classified? In a blog post published in November 2026, the Amazon Quick team offered their answer—not by providing a single definitive solution, but by introducing a shared vocabulary that allows different interpretations to coexist and switch seamlessly.

They break down agentic work into four fundamental questions: When (what triggers the work), What (the task content), Who (who performs it), and How (how it is executed). Triggers address both When and What; agents answer Who; and capabilities answer How. While this decomposition is straightforward, its value lies in enabling different implementation paths for the same request to exist not as mutually exclusive competitors, but as varying degrees of confidence within the same framework.

A 'confidence contract' defines the balance between the autonomy an agent retains and the extent to which the user pre-defines the process. The Amazon Quick team illustrated this with a concrete example: a user says, 'Monitor my Slack channel and send me a daily summary.' This request can be implemented in at least three ways: first, a scheduled task with a one-line instruction letting the agent decide how to proceed; second, a skill packaging explicit formatting rules and channel priorities; third, a workflow declaring deterministic steps and error handling. All three produce a daily summary; the difference lies solely in the latitude granted to the agent.

This distinction yields a practical inference: a user request like 'I want an agent that monitors Slack and sends a daily summary' usually does not require creating a new agent or workflow, but rather adding a trigger to an existing agent. Based on this, the Amazon Quick team merges chat, scheduled, and so-called 'autonomous' agents into a single actor—one you can converse with, schedule, and which can orchestrate and inspect its own past work.

Regarding the relationship between skills and workflows, they propose two dynamic concepts: crystallization and dissolution. A well-understood skill can tighten into a workflow; a workflow frequently encountering edge cases can loosen back into a skill. This transition is driven by their continuous learning framework, with specific mechanisms detailed in subsequent articles.

Important caveats apply: this is an internal vendor-specific vocabulary designed to unify architectural discussions across their own product line. The article provides no evidence of independent adoption, nor controlled experiments demonstrating that this classification actually reduces builder confusion. Its current value remains at the level of 'a clear attribution argument'—the authors explain why a shared vocabulary is needed, how it is structured, and how it changes the classification of specific requests. For readers building agent systems, this four-question decomposition and the concept of confidence contracts offer a directly usable thinking framework, but treating it as an industry standard is premature.

Sources :Amazon Web Services

Recherche

Greenlight Financial Says Luna's Memory Layer Pushes Autonomous Resolution Rate from 83% to Over 90%

Matériel
2026-11-07 00:55 GMT+8

A notable design choice for Greenlight Financial’s security operations agent, Luna, is that it does not rely on more powerful models or additional tools to improve accuracy; instead, it relies on memory.

Luna is a tiered multi-agent system where Tier 1 handles the triage of routine alerts, while Tier 2 manages complex cases requiring multi-step reasoning. With Tier 1 operating alone, the autonomous resolution rate plateaued at 83%. Greenlight reports that adding the memory layer pushed this figure above 90%.

The memory layer consists of two parts. The first is short-term memory with a 30-day rolling window: when a new alert arrives, Luna checks whether this pattern occurred in the past 30 days, how it was adjudicated, and whether it should be allowed through. Greenlight provided a specific example—an infrastructure role executes planned maintenance every Tuesday at 3 AM. A system without memory would re-flag this behavior weekly, whereas a system with memory learns after the first resolution that this is expected behavior and automatically adds it to the allowlist.

The second part is long-term memory, which stores semantic preferences and resolution templates beyond the 30-day window. For instance, cards originating from a specific dark web source have a 73% false-positive rate, so deduplication is prioritized; or resolution templates encoded for recurring case types.

What truly drives the accuracy increase from 83% to over 90% is the case-learning pipeline connecting these two memory components. An AWS Lambda function captures each case resolution result, while DynamoDB stores resolution patterns and deduplicates them. The key rule is: when Luna resolves a case in the same way three times, it records this as a confirmed pattern. Another Lambda function then processes these newly learned insights into actionable context for supervisors to consume during inference. This feedback loop allows Tier 1’s first-pass success rate to continuously improve.

Greenlight lists this approach as one of five lessons learned, calling it 'memory compounding': every resolved case teaches Luna something—a new allowlisted pattern, a confirmed false-positive source, or a resolution template. After six months of operation, Luna has accumulated organizational knowledge equivalent to the experience a new human analyst would need months to build.

It is important to note that all these figures come from Greenlight’s self-reported production measurements, published by AWS as the platform provider. The article does not disclose the denominator (whether the total volume of cases changed concurrently), does not explain selection effects (whether complex cases still relied on humans), and lacks a before-and-after experimental design. The reported improvement from 83% to over 90% combines the addition of Tier 2 with the contribution of the memory layer, making it impossible to attribute the gain solely to the memory mechanism itself.

Sources :Amazon Web Services

Recherche
Suivant →
Connexion / Inscription
LectureRechercheRadarCadre d'investissement

In terms of practical effects, validation was conducted in a constrained scenario involving the Trace to Trajectory service, which converts Trace data into trajectory data and frequently encounters new parsing exceptions in production. They selected 19 issues: approximately 10 produced implementations roughly equivalent to those of human experts, while another 5 approached expert level, compressing the delivery cycle from about one month to under a week. In offline experiments, they selected 20 high-quality human-expert Commits from the codebase, reverse-generated requirements to build a Benchmark, and had the Agent team complete these tasks, comparing their results item-by-item against expert implementations.

The authors frankly listed four categories of persistent issues: requirements may be clearly stated, but architectural constraints might not be transmitted effectively (for example, when aiming to extend existing API capabilities, an Agent might choose to add a new API, which is easier to complete for the isolated task but fails to meet the team's design requirements at the global system level); real-world scenarios always bring unforeseen problems (AI application inputs are far more open than traditional software); the same problem may recur (as code, business rules, and runtime environments change, experience must be continuously accumulated to avoid repeating pitfalls); and fixing one problem may impact other tasks (modifying a Skill may pass current use cases but cause regression in others). The existence of these issues indicates that multi-Agent orchestration does not run automatically once the framework is built; it requires continuous observation, adjustment, and accumulation.

Kuppusamy also highlights the necessity of defending against agent circumvention: an agent stuck in a feedback loop will seek the cheapest path to a green build, potentially shrinking test data arrays, commenting out assertions, swallowing errors with try-catch blocks, or directly editing thresholds. The countermeasure is to restrict the agent's write permissions to implementation source code only, rendering the snapshot tools and threshold metadata records as immutable infrastructure.

The boundaries of this method are also clear. Some limits resist meaningful unit testing: callouts require mocks that do not reflect real latency, platform event publish limits behave differently under test isolation, and asynchronous job limits are difficult to simulate at scale. These require supplementation with production monitoring. Sandbox tests cannot reproduce index contention and row locking under production concurrency, meaning thresholds during testing may underestimate actual consumption. Overly aggressive thresholds can cause build failures due to false positives rather than real logic errors; it is recommended to start generous, tighten based on historical data, and distinguish between warning tiers and violation tiers.

Volpato emphasized a troubleshooting trap in the article: you cannot rely solely on aggregate cache hit rates. They found that applications and gateways might both record the same model call, leading to double-counting of costs; conversely, if records lack cache fields, caching appears unused. Some records omit system instructions or tool definitions, making it impossible to judge why the provider didn't reuse previous inputs. When evaluating fix opportunities, the team also pointed out an easily overlooked cost dimension: some providers charge extra fees for cache writes. If you repeatedly write content that is rarely reused, costs may actually increase.

The value of this article lies not in discovering a brand-new caching principle—the mechanisms of prefix matching and tool order consistency are not new discoveries. Its contribution is demonstrating a real troubleshooting process: starting from aggregate cost anomalies, narrowing down to discrepancies at the individual request level, and ultimately pinpointing four specific code-level causes. For teams running LLM applications with poor caching results, this troubleshooting path and these four patterns are far more directly usable than any generic principles.

Taxbit Assist has been in production in the US and EU markets since May 2026. Internal analysis shows that more than 55% of users ask another question within 24 hours of their first. The average cost per conversation is less than 20 cents, with prompt caching technology providing approximately three-quarters of input tokens from the cache, drastically reducing costs. This practice provides an engineering paradigm worth referencing for building reliable AI assistants in regulated industries, particularly in retrieval enhancement, security boundaries, and continuous quality monitoring.

This leads to the article's core epistemological claim: the model distribution is the basis for interpretation. If all surviving models share a feature, the data likely supports it; if they disagree, the evidence is weak, pointing to what the next experiment should address. The Hodgkin-Huxley four-particle hypothesis only makes sense when you know that lower powers do not work—this is exactly the information provided by the distribution.

The article acknowledges that so far these systems have mainly been tested on tasks of rediscovering models already known to scientists, and evidence for their performance on new problems with no known answers remains sparse. But the authors believe this will improve as LLM capabilities in research tasks advance. Evidence they cite includes work by Romera-Paredes et al. (2024) and methods by Wahl et al. (2026).

In the interpretation step, the authors acknowledge this is the hardest step to hand over to AI: we can measure how well a model fits data, but we cannot measure whether it brings a better understanding of the system. They propose two paths: evaluating AI understanding through perturbation predictions, and having AI outputs help human scientists better understand the problem—for example, an AI system designed for quantum experiments that does not give a single setup, but writes a short program generating a whole family of experimental setups, from which physicists can directly read the underlying design principles.

The article returns to the story of Hodgkin and Huxley: their three-week struggle with the calculator was clumsy, but not wasted. Many insights from the model came from the process of creating it; they understood what the model was saying because they built it themselves and knew what didn't work. AI could complete the same computational work in an afternoon, but to provide understanding, it needs to deliver what the two scientists' slow work produced: not just the fitted model, but which parts are pinned down by data, which remain open, which alternatives failed during the process, and what new puzzles were uncovered along the way.

The authors conclude with mathematician Richard Hamming's words from 1962: the purpose of computing is insight, not numbers. A scientific model can provide an answer, but it is the process of constructing it that provides insight.

Security controls are implemented in layers: the MCP server runs in private subnets and is not directly exposed to the internet; only the client layer can route requests to it via a public-facing Application Load Balancer with AWS WAF. The Athena query tools enforce SELECT-only operations at the tool level, rejecting write operations before they reach the data lake. All tool calls are logged to Amazon CloudWatch in structured JSON, providing security teams with a unified audit point across all Agents and applications.

The transferable insight of this pattern is: when your number of Agents and datasets grow simultaneously, turning the onboarding of new data from a coding problem into a configuration problem significantly reduces marginal costs. But its applicability boundaries are equally clear—the entire implementation is deeply tied to the AWS service stack (ECS Fargate, Athena, Bedrock, DynamoDB); the accuracy of metadata files relies on manual maintenance; automatic handling mechanisms for description drift or expiration are listed in the text as future plans rather than implemented features; and the 15 to 20 second latency is a self-tested result by the team rather than an independent benchmark.