LLM self-improvement loops and AgentCore JSON/token optimizations

Nov 18, 2026•Items: 10

Systems & planning

  • LLM agents build self-improvement loops from basic tools

    TL;DR: LLM agents build context-based learning procedures from tools, compute, and an improvement goal, then improve on held-out games.

    • Teachers generate practice games, inspect scores and transcripts, then revise player text; canonical runs use 20 updates and 150 games (20 turns, 25k tokens/game).
    • Effective runs use calibrated-difficulty games, A/B tests, and validation suites; teachers also spend more effort on harder tasks.
    • Learned artifacts transfer across PuzzleScript-t20/t30, ARC-AGI-3 L1, and MazeBench, covering different horizons, mechanics, and 3D navigation.
    • Performance rises then plateaus with more updates; the study does not establish that the observed strategies cause the gains.

    Why it matters: If you are iterating on agent “teacher” loops, you can’t rely on wins in self-generated practice alone; this work reports transfer to multiple held-out game suites (PuzzleScript, ARC-AGI-3 L1, MazeBench), so evaluation needs explicit cross-suite validation rather than only measuring the games the teacher produced.

    Signals: Whether self-organized improvement extends to more open-ended domains where models have weaker priors remains an open question.

    Source: https://huggingface.co/papers/2611.23219

  • strands-mongodb adds persistent sessions and searchable…

    TL;DR: The strands-mongodb Python integration connects MongoDB to Strands for resumable agent sessions and searchable long-term memories across conversations.

    • SnapshotSessionManager loads MongoDBStorage state by session ID; reusing the ID resumes a conversation, and save_latest_on="message" saves each message.
    • MemoryManager uses MongoDBMemoryStore; a stable scope groups facts, while extraction=True invokes a model call to extract them.
    • Vector Search retrieves by meaning using Atlas automated embeddings; full-text matches terms, and hybrid combines both.
    • Use either backend alone or share one MongoDB deployment; identical memories are deduplicated per store and scope, and ttl_seconds can expire entries.

    Why it matters: For agents that must continue multi-day work, this provides a concrete persistence path: session state can be restored by session ID, while cross-session recall is mediated by memory scopes plus vector/full-text/hybrid retrieval. That reduces glue code between “resume the thread” and “retrieve durable facts,” since both are backed by the same MongoDB deployment.

    Signals: Try recall by starting a new session with the same memory scope and asking, “What test setup does this project require?”

    Source: https://strandsagents.com/blog/mongodb-memory-for-strands-agents/

  • Amazon Bedrock AgentCore JSON optimizations cut token…

    TL;DR: Flightscape’s Training Schedule Optimization agent reduced total token usage by approximately 71% and average trace latency by nearly 80% across a 5-question conversation run.

    • Heavy JSON artifacts move to S3; AgentCore memory stores content-addressed SHA-256 references, so identical payloads reuse keys.
    • Lists return a count, sample, and handle; the model fetches slices on demand.
    • For the heaviest query, input tokens fell 75%, output tokens 83%, and turn latency 94% (~165 s to 9.9 s).

    Why it matters: For agents whose tools emit large JSON, this describes a specific way to keep conversations usable over time: store full artifacts in S3, pass stable content-addressed references through memory, and return list “handles” instead of full arrays until the model requests slices. In the reported run, that directly reduced both context size (tokens) and turn time (latency) without making the full payload inaccessible.

    Signals: The post recommends identifying which tool outputs dominate context, starting with S3 artifact offloading, then adding paging and dictionary compaction as needed.

    Source: https://aws.amazon.com/blogs/machine-learning/reducing-token-costs-and-latency-in-amazon-bedrock-agentcore-json-workloads/

  • Codex runs local commands with user-controlled sandbox…

    TL;DR: The Codex sandbox runs local commands while enforcing configured filesystem and network limits across macOS, Linux, and Windows.

    • Codex runs commands on the user's machine.
    • The sandbox enforces filesystem limits controlled by the user.
    • The sandbox enforces network limits controlled by the user and supports macOS, Linux, and Windows.

    Why it matters: Users can control filesystem and network limits for Codex command execution on macOS, Linux, and Windows.

    Source: https://openai.com/index/inside-the-codex-sandbox

  • LangSmith for Coding Agents ties spend to pull requests

    TL;DR: LangSmith links coding-agent spend to pull requests and merge requests, enabling cost comparisons by outcome across agents.

    • Outcomes link threads to GitHub PRs or GitLab MRs and attribute spend when one thread maps to several PRs or several threads to one PR.
    • The dashboard groups spend by PR state, work type, model, skills, and thread length; non-PR sessions appear as unattributed spend, linked to their threads.
    • Teams can compare cost per merged PR before and after a model change, or compare providers running in parallel.
    • Supported traces include Claude Code, OpenAI Codex, Cursor, GitHub Copilot in VS Code, and Deep Agents.

    Why it matters: Teams can evaluate model and policy changes against both spend and merged-PR outcomes, then inspect the sessions behind expensive work. Separating unattributed spend helps teams account for sessions used for code review or investigation that do not produce a PR.

    Signals: LangChain invites feedback on what coding-agent outcomes to track next.

    Source: https://www.langchain.com/blog/langsmith-coding-agents-roi

  • Amazon Bedrock AgentCore Identity adds private-CA trust

    TL;DR: Amazon Bedrock AgentCore Identity validates self-hosted IdP TLS certificates against stored private CAs for agent OAuth requests.

    • CA PEMs must contain valid root or intermediate certificates and be ≤16 KB; one secret or S3 object per provider can hold multiple CAs.
    • Private CA use requires a private endpoint and VPC Lattice.
    • For rotation, trust both CAs, update the provider and wait for READY, switch the IdP certificate, then remove the old CA and update again.
    • CloudWatch publishes EarliestCertificateDaysToExpiry when agents request tokens; changes to the CA file require updating the provider to reload it.

    Why it matters: Trusting both CAs during the rotation helps minimize downtime when changing the IdP certificate. Operators must update the credential provider after changing the stored PEM because AgentCore Identity reads the CA data only when the provider is created or updated.

    Signals: AgentCore Identity does not check certificate revocation lists or use OCSP; it continues trusting an IdP server certificate until it expires or its issuing CA is removed.

    Source: https://aws.amazon.com/blogs/machine-learning/private-certificate-authority-support-in-amazon-bedrock-agentcore-identity/

  • TCP4D reports 7.60 mm ATE on DROID with monocular RGB to…

    TL;DR: TCP4D tracks metric monocular-video TCP poses and generates trajectories, with 7.60 mm ATE and 69.19% RoboTwin success.

    • From video and an initial 2D TCP query, the tracker decodes metric depth, camera rays, SE(3) poses, and gripper states; tracking success is 100% on both datasets.
    • DiT combines robot state, four history frames, wrist images, language, and shared 4D features to predict 32 future TCP states using four Euler inference steps.
    • Augmentation retargets recovered motion and synthesizes observations without recorded source-robot states; joint training raises target success 41.5% over augmented-only.
    • On Berkeley AUTOLAB UR5, ten-episode fine-tuning reaches 64.28% APD, 8.85 mm ATE, and 98.48% gripper accuracy.

    Why it matters: TCP4D provides a way to derive metric TCP and gripper annotations from RGB videos, then reuse recovered motion to create demonstrations for another embodiment. The reported joint-training result gives a concrete evaluation target for testing whether augmented data improves target-robot policy performance.

    Signals: The augmentation pipeline applies to alternative embodiments that satisfy reachability.

    Source: https://huggingface.co/papers/2611.23143

Evaluation, grounding & uncertainty

  • Amazon Bedrock AgentCore Gateway routes private APIs…

    TL;DR: Amazon Bedrock AgentCore Gateway routes private API traffic through a network-account VPC Lattice resource gateway and central firewall.

    • Share one VPC Lattice resource configuration per backend with the AgentCore account through AWS RAM; Gateway targets reference the shared configuration.
    • ALB forwarding rules validate token issuer, scope, and Gateway app client ID; private REST APIs require an authorizer on every method.
    • Tests in us-east-1 across three member accounts and a management account rejected missing or mismatched tokens with HTTP 401 before backend invocation.

    Why it matters: In hub-and-spoke setups, this pattern makes the inspection boundary explicit: API traffic is forced through the network-account resource gateway and token validation happens at the ALB rules/authorizers before the backend is invoked. To avoid deployments that bypass inspection or fail at runtime, you need end-to-end tests that cover both routing (correct gateway placement and reply path) and auth policy enforcement (issuer/scope/client-ID checks).

    Signals: Run the validation checks in a non-production copy of your network account using your own firewall before adopting the pattern.

    Source: https://aws.amazon.com/blogs/machine-learning/connect-amazon-bedrock-agentcore-gateway-to-private-apis-in-a-hub-and-spoke-network-with-centralized-inspection/

  • ChatGPT for Sales adds a Sales plugin and 30+ partner…

    TL;DR: ChatGPT for Sales adds a Sales plugin and 30+ new and expanded partner plugins for sales workflows.

    • Use the plugins to research prospects and prepare pitches.
    • They can also update a CRM and help move deals forward.

    Why it matters: If you are evaluating tool-augmented assistants for sales operations, this expands the set of tool endpoints exposed via ChatGPT—covering prospect research, pitch preparation, and CRM updates—so you can test workflows that require both information gathering and state-changing actions (e.g., CRM writes) within a single agent session.

    Source: https://openai.com/index/introducing-chatgpt-for-sales

  • LangSmith Sandboxes use microVMs to isolate agent code

    TL;DR: LangSmith Sandboxes run agent-written code in dedicated microVMs with separate filesystems, configurable network access, and controllable lifecycles.

    • An authorization proxy injects credentials into outbound traffic after it leaves the sandbox, keeping secrets outside the reach of untrusted code.
    • Running the agent inside the sandbox requires rebuilding and redeploying its image for updates; Deep Agents supports both patterns.

    Why it matters: Filesystem and network controls limit which data agent-written code can access and where it can send data. Keeping credentials outside the sandbox can reduce their exposure to untrusted code, while the choice of integration pattern affects update workflows and execution latency.

    Signals: Sandboxes alone do not fully eliminate any aspect of the lethal trifecta; the guide presents them as a way to narrow data access and external communication.

    Source: https://www.langchain.com/blog/how-to-choose-the-right-sandbox-for-your-agent

Subscribe

Get Applied Signals weekly newsletter in your inbox