Building agents, scoring decisions and directing compute

News

Build autonomous AI agents with Amazon Bedrock and Spring AI

AWS has published a walkthrough for Java developers building autonomous agents with Amazon Bedrock and Spring AI. It follows an 11-stage pipeline from request to grounded answer. The walkthrough brings construction and deployment together, taking the agent onto AWS through Amazon Bedrock AgentCore.

Production infrastructure without a fixed framework

The walkthrough requires Java JDK 21. It uses Spring Boot 4.1 with Spring AI 2.0 and spring-ai-agentcore 2.0. The implementation covers tool calling and conversation memory. It also addresses resilience patterns and orchestration across multiple agents. AgentCore accepts the developer's preferred agent framework and foundation model. Its production infrastructure includes a managed runtime, memory, browser automation, code execution and identity management. (AWS Machine Learning)

thinkidiot take: The walkthrough puts 11 stages between a request and a grounded answer. I would use those stages as a review checklist, with particular attention to tool calling, memory and resilience. AgentCore's framework and model flexibility lets that review start with the stack I choose. For me, the production infrastructure is the stronger reason to try this than autonomy alone.

Gemini Decisions API: Fast, calibrated multimodal decisions

Google has introduced the Gemini Decisions API, powered by Gemini Decision 1. It scores options in a single forward pass and returns probabilities and confidence scores. Pricing is $0.10 per 1 million input tokens, with zero output tokens billed. The API supports up to 1,000 independent questions against one multimodal input.

Confidence scores give code a route to review

Supported inputs include text, images, audio, video and PDFs, with input contexts up to 256K tokens. Questions can use yes/no, choice or rubric-scoring formats. Google reports median model compute latency of 50 to 100 milliseconds and end-to-end latency of 150 to 250 milliseconds across multimodal inputs and contexts up to 16K tokens. That latency stays flat from 1 to 100 questions per request. Each answer's confidence score runs from 0 to 1, allowing code to send ambiguous cases to a fallback or human reviewer. Across the shared benchmark suite, the Decisions API is nearly five times cheaper than Gemini 3.5 Flash-Lite with the Interactions API. (Google)

thinkidiot take: Zero output tokens are billed, and the shared benchmark puts this API at nearly five times cheaper than Gemini 3.5 Flash-Lite with the Interactions API. I would test it on repeated rubric questions against the same input, using confidence scores to route ambiguous answers to review. I would keep the stated latency scope separate from the larger input and question limits when evaluating it. The combination of explicit scores and input-only billing makes this a compelling option for bounded decisions.

Intelligent Delivery: Making Every Unit of Compute Serve Better Ads

Meta Engineering has described Intelligent Delivery, its system for allocating compute across ads delivery. Meta credits it with roughly 10% additional ads ranking performance across major surfaces from 2017 through the first half of 2026. That gain sits on top of model and system advancements. The system continuously directs resources toward requests, models, hardware fleets and ranking stages where extra compute has the greatest impact.

A local gain does not guarantee a system gain

Ads ranking models are growing toward LLM scale faster than the hardware running them can keep up. The delivery system spans multiple ranking stages, hundreds of models, generations of hardware and many data centers. An extra unit of compute produces different returns depending on the product surface and user intent. Candidate quality and system state also affect that return. Intelligent Delivery uses an ML-driven adaptive optimization layer that is increasingly operated by AI. Estimating results is only the start, because the serving stack must also support dynamic control. Optimizing individual parts does not automatically optimize the whole system. (Meta Engineering)

thinkidiot take: Meta attributes roughly 10% additional ranking performance to compute allocation on top of model and system improvements. I would treat that as a reason to measure where extra compute pays off before expanding a model. The requirement for dynamic control makes this a serving-system problem as much as a modeling problem. My judgement is that allocation deserves a place alongside model quality in performance work.

Who could replace Jensen Huang? A highly unscientific list of possible successors

TechCrunch has published a self-described highly unscientific shortlist of possible successors to Nvidia CEO Jensen Huang. The outlet says Nvidia has no succession plan and describes Huang as under pressure. It cites Kalshi odds of 30% for Huang surviving the week in his role. The article presents speculative candidates, not an announced leadership change.

CUDA experience sits alongside executive credentials

Lisa Su runs AMD, described as Nvidia's most credible rival. Eric Schmidt ran Google from 2001 to 2011. He also chaired the National Security Commission on AI from 2018 to 2021. Lip-Bu Tan reported Intel third-quarter revenue up 21% to $16.5 billion, then warned that fourth-quarter results would fall short of Wall Street forecasts. Bret Taylor co-created Google Maps, served as Facebook's CTO and chaired Twitter's board through its sale to Elon Musk. Ian Buck helped develop CUDA, the chip software central to Nvidia's dominance in AI. (TechCrunch)

thinkidiot take: The 30% figure is a Kalshi market estimate, while the successor list is explicitly speculative. I would give Buck's role in developing CUDA particular weight when reading these profiles. That experience connects directly to software the source identifies as central to Nvidia's AI dominance. For my money, that connection is more relevant than the prominence of a candidate's previous titles.

Gilbert + Tobin rethinks the business of law with AI

OpenAI has published a conversation with Sam Nickless of Gilbert + Tobin. Nickless is the firm's Partner and Chief Executive Officer. The conversation is presented as a look at rethinking the business of law with AI.

The supplied account stops short of implementation detail

The supplied evidence identifies Sam Nickless as Gilbert + Tobin's Partner and Chief Executive Officer and the conversation's topic as rethinking the business of law with AI. It provides no implementation details or measured outcomes. (OpenAI)

thinkidiot take: The supplied evidence identifies a conversation with the firm's Partner and Chief Executive Officer but includes no measured outcomes. I would want a concrete workflow and its results before using this as a basis for an implementation decision. The conversation's topic signals an interest in rethinking the business of law with AI. On the evidence provided, I would treat this as a statement of direction, not a demonstrated operating result.

Trending AI Papers

Ranking source: Hugging Face Papers for 2026-11-12.

Tree-Ising: Repairing Language Models with Bit-Level Ising Edits

A language model can get stuck repeating its reasoning instead of reaching an answer. Tree-Ising tries to fix that behavior by changing small parts of the numbers stored inside the model. It uses a mathematical search to choose those changes. The aim is to improve answers with less computation than an earlier repair directed by another language model.

• Problem: The paper tackles reasoning loops in a language model without retraining it. An earlier repair used a language model to inspect and change the stored weights, but required 158 agent turns, 89.7 million tokens, and 50 forward-pass requests.
• New idea: Tree-Ising searches for a limited set of changes to weights, the stored numbers that control a model's calculations. It allows changes to a weight's sign or numerical scale while keeping other parts of its stored representation fixed. Measurements from running the model guide the search toward less repetition and more concluding behavior while protecting useful outputs. The method splits the search into separate problems for each row of weights and solves them on a GPU, a processor suited to parallel calculations.
• Simple example: Think of adjusting a sound mixer to quiet a repeating hum while keeping the useful sound intact. Tree-Ising similarly looks for small internal adjustments that suppress looping behavior without disrupting productive work.
• Evidence: On Qwen3.5-0.8B, Tree-Ising scored 54.6% on MATH-500, compared with 51.7% for the earlier agent repair and a reported 7.9% for the base model. Its alternative solver scored 55.1%, a statistically indistinguishable result. Both solvers beat the agent repair on all five math benchmarks, with statistically significant gains on MATH-500 and GSM8K after correction for multiple comparisons. Tree-Ising changed 13% to 17% fewer weights and reduced bit flips by a factor of 2.2 to 2.3. It used four forward-pass requests and no LLM tokens, with about $0.90 in GPU time for the annealing recipe. On Qwen3.5-2B, the same recipe raised greedy GSM8K accuracy from 21.6% to 69.4%.
• Limitation: The abstract reports math results for two Qwen3.5 model sizes; broader effects on other abilities and model families are not reported in the supplied abstract. Its quantum hardware demonstration covers only an eight-variable repair subproblem.
• Why it matters: This work shows that targeted changes to stored weights can repair a reasoning failure at much lower computational cost than the earlier agent approach.
• Paper: Tree-Ising: Repairing Language Models with Bit-Level Ising

Don't Just Trust Your Memory: Evidence-Linked Memory Reduces Memory-Induced Degradation in LLM Agents

An AI assistant can save advice from earlier tasks and use it when tackling new ones. That advice can also steer it into mistakes. WikiTrace keeps the supporting history attached to each saved lesson so the assistant can inspect how it arose. The goal is to make past experience useful without turning a mistaken lesson into a recurring error.

• Problem: Saved lessons can cause an assistant to fail at tasks it would otherwise solve. Existing approaches often derive advice from task histories marked only as successes or failures, then supply the advice without those histories. This leaves the assistant unable to check whether a lesson is wrong or applies to the current situation.
• New idea: WikiTrace is a memory system that connects each short lesson to the record of the task that produced it. Each lesson links to both an explanation of the outcome and the full sequence of actions. When advice lacks needed detail, conflicts with another lesson, or comes from a failed task, the assistant uses command-line tools to inspect those linked records. It can then recover missing context or correct the lesson before taking action.
• Simple example: Imagine a work note that says to skip a step in a routine task. A link to the original work log lets you check why that step was skipped and whether the same circumstances apply now.
• Evidence: Across five agent benchmarks, WikiTrace consistently outperformed existing memory approaches and a comparison system given the same lessons without their linked evidence. It also reduced failures caused by memory. The abstract gives no numerical scores or sizes for these improvements.
• Limitation: The abstract does not report how much extra time or computation it takes to inspect the linked records, so the cost of the improvement is unclear.
• Why it matters: Keeping evidence attached to advice helps an assistant check its past experience before letting it guide a new task.
• Paper: Don't Just Trust Your Memory: Evidence-Linked Memory

MMDM: Measuring Massive Multitask Decision Making

Some AI models choose directly from supplied options instead of writing out an answer. MMDM is a test collection built to examine how well these models handle difficult choices. It includes situations with lengthy inputs, many options, and rules that connect choices to one another. The results show that strength on general knowledge does not guarantee reliable selection under these conditions.

• Problem: Existing tests often reuse material that models may have encountered before, making it harder to judge performance on unfamiliar tasks. They also do not adequately combine long inputs, large sets of options, and complicated relationships between choices.
• New idea: MMDM, short for Massive Multitask Decision Making, is a benchmark, a collection of questions used to compare model performance. It combines newly written tasks with material rearranged or rewritten from sources to create fresh contexts. Questions cover choosing one option, choosing several options, and soft labels, which allow graded judgments rather than only right-or-wrong choices. The tasks include tracking an assistant's current situation, selecting tools, judging preferences, and scoring against stated criteria.
• Simple example: Choosing a tool for an assistant illustrates the challenge. Recognizing a useful tool is only part of the task when the choice must also fit the assistant's current situation and obey rules linking the available options.
• Evidence: MMDM contains 5,448 questions across 16 task categories, with 2 to 1,024 options and inputs reaching 64,817 tokens. The authors evaluated 28 decision models. Perplexity Decider-V1.2 scored 78.75% on world knowledge under Hard Single-select Accuracy, compared with 53.95% on option logic and 47.95% on constraint planning. The highest Hard Multi-select Accuracy among all evaluated models was 36.81%.
• Limitation: The abstract reports performance on the test collection but does not establish how closely those scores predict success in real deployments. It identifies weaknesses without testing a method to fix them.
• Why it matters: MMDM helps reveal whether a model can make choices that satisfy connected rules, beyond answering familiar knowledge questions.
• Paper: MMDM: Measuring Massive Multitask Decision Making

Trending AI Repositories

Ranking source: GitHub Trending.

GoogleChrome/modern-web-guidance-src

Modern Web Guidance is a set of skills that embed web platform expertise. This source repository includes the code and documentation used to author, calibrate, and evaluate that guidance.

• What it is: This TypeScript repository holds the source for GoogleChrome/modern-web-guidance. It sits behind the published Modern Web Guidance skills.
• What it does:
• Who it helps: It helps people authoring web platform guidance. They can use the repository's code and documentation to calibrate and evaluate its contents.
• Limitation: The supplied README excerpt does not include setup or usage instructions.
• Repository: GoogleChrome/modern-web-guidance-src

shadcn/improve

improve is an agent skill whose product is a plan. It focuses on understanding a codebase and judging which changes are worth making before implementation begins.

• What it is: The skill sits between a user's request and another agent's implementation work. Its output is a set of self-contained specs in the plans directory.
• What it does: Use your most capable model to audit your codebase and write plans for cheaper models to execute.
• Who it helps: It helps developers who hand implementation work to agents. They can give those agents self-contained specs with the proposed work already defined.
• Limitation: The skill does not implement changes itself. An agent or human must carry out the plans.
• Repository: shadcn/improve

openai/codex-security

Codex Security provides security workflows for working on vulnerabilities in code. It offers entry points in Codex, a terminal, and automation, including a GitHub Action.

• What it is: The repository brings together Codex security workflow instructions and tools for repository scans. It supports both interactive use and automated workflows.
• What it does: OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
• Who it helps: It helps developers investigate vulnerabilities in their code. They can choose a workflow in Codex, scan a repository from a terminal, or use a GitHub Action for automation.
• Limitation: The terminal workflow requires installing the CLI.
• Repository: openai/codex-security