Uncategorized

Backpropagation is a global algorithm: a forward pass, then a backward pass, then a weight update, each locked behind the previous one. Brains have no known mechanism for that kind of network-wide phase locking, which is why local-learning alternatives such as predictive coding (PC) keep drawing research interest. Sakana AI researchers propose Augmented Lagrangian Predictive Coding (PC-ALM), a variant of PC that keeps every update layer-local yet recovers backprop-aligned credit signals. The research team reports training residual MLPs up to 1000 layers within about 2 percentage points of backprop on MNIST. Is it deployable? Yes, as research code: an MIT-licensed JAX reference implementation runs on CPU and reproduces the paper’s width-depth grid. It is a training method, not a model, and has only been tested on small image benchmarks. Why standard PC stalls in deep, narrow networks PC treats every hidden activation as an optimization variable and penalizes the squared mismatch between each layer’s activation and the prediction arriving from the layer below. Inference is gradient descent on that energy; learning is a Hebbian-like weight step. The catch is that supervision enters at the output and must diffuse through a chain of local compromises. In deep, narrow networks the credit signal fades long before it reaches the input. Innocenti et al. characterized this PC-BP gap as a function of width and depth, and it is worst when width is smaller than depth. What PC-ALM changes PC-ALM starts from the constrained view of training: minimize the supervised loss subject to hi=σ(Wihi−1)h_i = sigma(W_i h_{i-1}) at every layer. PC is the quadratic-penalty relaxation of that problem. PC-ALM uses the augmented Lagrangian instead, attaching a Lagrange multiplier λi∈ℝdisuch thatdim(λi)=dim(hi)lambda_i in mathbb{R}^{d_i} quad text{such that} quad text{dim}(lambda_i) = text{dim}(h_i) to each layer constraint while keeping PC’s penalty. Setting λ = 0 recovers PC exactly. Inference alternates 2 local steps: a primal gradient step on the activations, and a dual step λi←λi+αrilambda_i leftarrow lambda_i + alpha r_i that accumulates the layer’s prediction error. Completing the square shows each primal step is a standard PC step with the prediction target shifted by −λi/ρ-lambda_i/rho. After T steps the weight update acts on the composite signal λi+ρrilambda_i + rho r_i. The research team read this as a PI controller per layer: the prediction error is the proportional term and the multiplier is the integral term. α = 0 gives PC; α = ρ with the inner problem solved exactly gives the classical method of multipliers. Exact backprop gradients in the linear case LeCun observed in 1988 that the Lagrange multipliers of a constrained network equal the backprop adjoints at a KKT point. The team proves that in linear PC networks, under a spectral-radius stability condition, PC-ALM converges to that KKT point: activations return to their forward-pass values while each λilambda_i integrates to the exact BP adjoint. The per-mode stability bound is ηhσi2(2ρ+α)<4eta_h sigma_i^2 (2rho + alpha) < 4, which reduces to PC’s condition at α = 0. Unlike PC’s monotone gradient flow, PC-ALM’s iteration matrix has complex eigenvalues that produce damped oscillations; α sets their frequency but not their decay rate. Results The research team sweeps residual MLPs with width and depth from 8 to 128 on Fashion-MNIST and MNIST under the mean-field parameterization of Innocenti et al., training for 1 epoch. With an inference budget of T = 2L, PC-ALM matches backprop across every width, depth, and activation (identity, tanh, ReLU), while PC drops sharply in deep, narrow cells. The repo’s reference cell (width 32, depth 32, ReLU, Fashion-MNIST) reports 78.66% test accuracy for BP, 68.13% for PC, and 77.75% for PC-ALM, with gradient cosine to BP rising from 0.604 to 0.909. The research extends the picture: 1000-layer residual MLPs on MNIST (width 32, ReLU, 5 epochs) stay within roughly 2 points of BP, and PC-ALM improves over PC on every benchmark tried, including ResNet-18 on CIFAR-10 and Tiny ImageNet. Key Takeaways PC-ALM adds a per-layer Lagrange multiplier to predictive coding; every update stays layer-local. In linear networks the multipliers converge to exact backprop gradients. Matches BP across the 8 to 128 width-depth grid at T = 2L; PC fails in deep, narrow cells. Trains 1000-layer residual MLPs within about 2 points of BP on MNIST. MIT-licensed JAX code reproduces the results on CPU. Check out the Paper, Blog, and GitHub Repo. All credit goes to the researcher of this project. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post Sakana AI Researchers Introduce PC-ALM, a Layer-Local Alternative to Backpropagation That Trains 1000-Layer Networks appeared first on MarkTechPost.

AWS introduced Pizza Bot, as a self-hosted application for AI tasks that continue while users work elsewhere. It organizes completed results and pending decisions into an email-style inbox. Earlier versions served more than 2,000 people inside Amazon, supporting meeting preparation, email drafting, Slack summaries, CRM logging, and research. The public application was rebuilt as an open source project. Deployable: Yes. Pizza Bot offers macOS, Windows, and Linux desktop builds, and browser and terminal clients connected to a local or standalone backend. Its code is licensed under Apache 2.0. An Inbox for Asynchronous Work Pizza Bot separates tasks into All, the thread history; Unread, completed work awaiting review; and Action, work paused for approval or an answer. Users can organize threads into folders and inspect delegated workers in the Activity panel. Tasks can start manually, through cron schedules, or through webhooks. The server owns scheduling. After downtime, missed cron intervals produce 1 catch-up run instead of replaying every missed interval. Trigger occurrences are recorded durably. How the Runtime Works The application uses DeepAgents and LangGraph for stateful execution. A Hono API server owns runtime execution and storage. Electron and browser clients share a React interface, while all clients communicate with the server over HTTP and server-sent events. LangGraph checkpoints retain thread state and approval pauses; separate SQLite stores hold cross-thread memory and application metadata. Reconnecting clients can replay buffered events. Closing a thread or disconnecting a client does not stop a running server. However, quitting the desktop app stops its embedded server and ends active runs. Checkpoints preserve the thread, but the step in flight can be lost. An always-on backend is required for work to continue after that desktop app exits. Skills, Tools, and Approval Controls Pizza Bot supports Amazon Bedrock, Anthropic, Google Gemini, OpenAI, OpenRouter, and Ollama. Configure a provider under Settings > Providers before running tasks. The agent has scratch-file operations and a sandboxed JavaScript interpreter without network or host-filesystem access. It can delegate through task when ready skill workers exist. The filesystem layer separately supports explicit folder grants and persistent memory. MCP servers expose external tools. Each SKILL.md defines a worker’s instructions and scoped tool access. A skill becomes callable only when its declared dependencies are available. Existing Claude Code-compatible .mcp.json configurations are supported, and plugins package skills with MCP servers. Skill authors configure interruptOn and allowedDecisions to require approval for specific tools. Depending on that policy, users can approve, edit proposed arguments, or reject an action. These controls must be configured for the relevant tools. Interactive Explainer Run the illustrative custom-skill workflow below. Compare an always-on backend with an embedded desktop server, close the client during execution, and approve, edit, or reject the proposed action. Animation timing is illustrative; no external actions occur. PIZZA BOT / BACKGROUND WORKIllustrative custom skill Backend locationAlways-on serverEmbedded in desktop Run example Close desktop Client: OpenServer: RunningCheckpoint: None WorkerApprovalResult Start a research brief, then close the desktop while it runs. All 0 Unread 0 Action 0 Prepare a research brief The custom skill gates its publish tool with interruptOn. publish_brief({title: “Research brief”}) Proposed title ApproveEditReject Read result Desktop closed Open the desktop to review its inbox. Simulation only. No external calls.Approval specification Key Takeaways An inbox for background agents: Pizza Bot organizes task history in All, completed work in Unread, and requests for approval or input in Action. Tasks support manual, cron, and webhook triggers. Persistent execution with DeepAgents and LangGraph: Checkpoints preserve thread state and approval pauses. Tasks continue after client disconnection while the backend remains running. Multiple model providers: Pizza Bot supports Amazon Bedrock, Anthropic, Google Gemini, OpenAI, OpenRouter, and local models through Ollama. Configured providers and tools can receive task data. Scoped skills and configurable approvals: MCP servers expose tools, while SKILL.md files define specialist workers. Tool-specific policies let users approve, edit, or reject proposed actions. Self-hosted and deployable: Apache 2.0 code, desktop builds, and standalone backend options are available. Each SQLite data directory supports 1 backend process. Check out the Technical details and GitHub Repo. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post AWS Introduces Pizza Bot: An Open Source Inbox for Background AI Agents appeared first on MarkTechPost.

An agent, in its simplest form, is an LLM calling tools in a loop. That loop works for short jobs. Give it a task that runs for an hour and 200 tool calls, and it breaks in 2 predictable ways. The AWS Samples design guide for autonomous cloud coding agents names them directly: shallow agents suffer from context overflow, get distracted (goal loss), and do not maintain state over long periods. The layer that fixes this is not the model. It is the harness, which AWS describes as managing everything but the model. This article opens up that layer. Compaction, memory strategy, context budgeting, and todo-state are the machinery that turns a shallow loop into a deep agent. We look at how LangChain Deep Agents, Claude Code, Manus, OpenAI Codex, and Amazon Bedrock AgentCore implement each one, with the actual thresholds they ship. Why a bigger window does not fix it The obvious fix is a larger context window. The evidence says it helps less than expected. Chroma’s Context Rot report evaluated 18 LLMs, including GPT-4.1, Claude 4, Gemini 2.5, and Qwen3, and found that performance grows increasingly unreliable as input length grows, even on simple retrieval tasks. Anthropic’s context engineering guide explains the mechanism: attention creates n² pairwise relationships for n tokens, so every added token depletes a finite “attention budget.” Context is a resource with diminishing returns, not a bucket. For an agent loop, this is worse than it sounds. Manus reports that a typical task needs around 50 tool calls, and that the input-to-output token ratio runs near 100:1. Each observation lands in context and stays there. The original instruction drifts toward the middle of the window, which is exactly where recall degrades. Goal loss is not only a model bug. It is the expected outcome of an unmanaged context on a long enough task. Mechanism 1: Context budgeting and offloading The first job of a harness is deciding what never enters the window at all. Deep Agents ships 2 offloading rules with hard numbers. When a tool response exceeds 20,000 tokens, it is written to the filesystem and replaced with a file path plus a preview of the first 10 lines. When session context crosses 85% of the model’s window, older write and edit tool calls, whose full file contents already live on disk, are truncated to a pointer. Only after offloading runs out of room does the harness fall back to summarization. Claude Code applies the same budgeting to what loads before the first prompt. Auto memory is capped at the first 200 lines or 25KB. MCP tool schemas stay deferred by default, with only tool names listed, and full schemas load on demand via tool search. After compaction, any re-read file over 5,000 tokens comes back as a path reference rather than content. The context window simulation in the Claude Code docs makes the payoff concrete: a research subagent reads 6,100 tokens of files and returns a 420-token result to the parent. That subagent pattern is budgeting at the architecture level. Anthropic’s guide notes that each subagent may burn tens of thousands of tokens exploring, but returns a distilled summary, often 1,000 to 2,000 tokens. The AWS AgentCore walkthrough builds exactly this: a coordinator spawns 3 browser subagents in parallel, each in its own MicroVM, and an analyst subagent receives only their structured findings. AWS reports a 4 to 6 minute expected runtime, and notes that sequential processing would take up to 3x longer. Mechanism 2: Compaction When offloading is not enough, the harness summarizes. Compaction is the practice of taking a conversation nearing the window limit, summarizing it, and reinitiating a new context with the summary. It is also where goal loss most often happens, because a lossy summary can drop the one constraint that mattered. The implementations differ in what they promise to keep. Claude Code’s compaction prompt preserves architectural decisions, unresolved bugs, and implementation details while discarding redundant tool outputs. Right after compaction it re-reads up to 5 of the files modified most recently, reloads the rules matching those files, and re-injects invoked skill bodies, capped at 5,000 tokens per skill and 25,000 total. The docs are explicit that detailed instructions from early in the conversation may be lost, which is why persistent rules belong in the project-root CLAUDE.md, which is re-injected from disk. Users can steer the pass with /compact focus on the auth bug fix or move the trigger point with /autocompact. Deep Agents made goal preservation a structural feature. Its summary is a structured document with dedicated fields for session intent, artifacts created, and next steps. The LangChain team added those fields after forced-summarization experiments showed the change improved performance. The full original transcript is also written to the filesystem, so a fact that was summarized away can be recovered by read_file later. Compaction has moved into the API layer too. OpenAI’s Responses API offers server-side compaction via context_management with a compact_threshold, plus a standalone /responses/compact endpoint that returns a compacted context window containing an opaque encrypted compaction item; OpenAI instructs developers to pass that returned window unchanged into the next call. OpenAI says Codex relies on this mechanism to sustain long-running coding tasks. The Claude Developer Platform exposes a compact_20260112 context-management edit with custom instructions and a pause_after_compaction option for inserting content before the model continues. When you write custom instructions there, they replace the default prompt entirely, so a compaction prompt is a real engineering artifact, not a setting. Mechanism 3: Todo-state and recitation Compaction protects the goal at the moment of summarization. Todo-state protects it on every turn in between. Manus described the trick plainly: its agent creates a todo.md and rewrites it step by step, checking items off. Rewriting the list recites the objectives into the end of the context, pushing the global plan into the model’s recent attention span and reducing “lost in the middle” drift. No architecture change is required. It is natural language used to bias the model’s own attention.

In this tutorial, we build an end-to-end hierarchical Neural Radiance Field (NeRF) using JAX, Flax, Optax, and the volume-rendering primitives provided by jax3d. We first construct a synthetic multi-view dataset from an analytic scene containing volumetric geometry and view-dependent radiance, using sample_along_rays and volume_rendering to establish the forward rendering process. We then implement a NeRF with positional encoding, skip connections, separate coarse and fine networks, and view-direction conditioning, followed by hierarchical importance sampling through sample_piecewise_constant_pdf. We train the model with JAX JIT compilation, Adam optimization, exponential learning-rate decay, and gradient clipping, and finally evaluate novel-view synthesis using PSNR, depth and opacity visualization, sampling diagnostics, 360-degree rendering, and marching-cubes geometry extraction. Copy CodeCopiedUse a different Browser import os, sys, subprocess, importlib.util, functools, dataclasses, time, math def _sh(cmd): subprocess.run(cmd, shell=True, check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) print(“Installing dependencies …”) _sh(f'{sys.executable} -m pip install -q “etils[array-types,epy,etree,enp]” ‘ f’chex flax optax scikit-image’) REPO_DIR = “/content/jax3d” if os.path.isdir(“/content”) else os.path.abspath(“./jax3d”) if not os.path.isdir(REPO_DIR): print(“Cloning google-research/jax3d …”) _sh(f”git clone -q –depth 1 https://github.com/google-research/jax3d.git {REPO_DIR}”) def _load_module_by_path(name, path): “””Load a single .py file without triggering the parent package __init__. `from jax3d.math import volume_rendering` also works if you run `pip install .` inside the clone, but that pulls in gin/tfds/etc. “”” spec = importlib.util.spec_from_file_location(name, path) mod = importlib.util.module_from_spec(spec) sys.modules[name] = mod spec.loader.exec_module(mod) return mod _VR_PATH = os.path.join(REPO_DIR, “jax3d”, “jax3d”, “math”, “volume_rendering.py”) if not os.path.exists(_VR_PATH): _VR_PATH = os.path.join(REPO_DIR, “jax3d”, “math”, “volume_rendering.py”) try: j3vr = _load_module_by_path(“j3d_volume_rendering”, _VR_PATH) except Exception as e: raise SystemExit( f”Could not load {_VR_PATH}: {e}n” “Try: pip install -U ‘etils[array-types,epy,etree,enp]==1.9.4’ and re-run.” ) import numpy as np import jax import jax.numpy as jnp import flax.linen as nn import optax from flax.training import train_state import matplotlib.pyplot as plt from PIL import Image print(“jax”, jax.__version__, “| device:”, jax.devices()[0].device_kind, f”({jax.devices()[0].platform})”) print(“jax3d volume_rendering API:”, [n for n in (“sample_along_rays”, “volume_rendering”, “sample_piecewise_constant_pdf”, “sample_1d”) if hasattr(j3vr, n)]) @dataclasses.dataclass class Config: H: int = 64; W: int = 64 n_train_views: int = 24; n_test_views: int = 3 cam_radius: float = 3.2; fov_deg: float = 40.0 near: float = 1.9; far: float = 4.7 gt_samples: int = 256 n_coarse: int = 64; n_fine: int = 64 deg_pos: int = 10; deg_dir: int = 4 width: int = 128; depth: int = 6; skip: int = 3 batch_rays: int = 2048; steps: int = 2500 lr_init: float = 5e-4; lr_final: float = 5e-6 chunk: int = 4096 grid_res: int = 96 cfg = Config() if jax.devices()[0].platform == “cpu”: print(“n!! No GPU detected — switching to a small CPU-friendly config.”) print(” (Runtime > Change runtime type > T4 GPU for the full version.)n”) cfg = dataclasses.replace(cfg, H=40, W=40, n_train_views=14, steps=400, gt_samples=128, n_coarse=32, n_fine=32, width=64, depth=4, skip=2, batch_rays=1024, chunk=1600, grid_res=64) def _normalize(v, axis=-1): return v / (np.linalg.norm(v, axis=axis, keepdims=True) + 1e-9) def look_at(eye, target=(0., 0., 0.), up=(0., 0., 1.)): “””OpenGL/NeRF convention camera-to-world: +x right, +y up, camera looks at -z.””” eye, target, up = map(lambda a: np.asarray(a, np.float32), (eye, target, up)) fwd = _normalize(target – eye) right = _normalize(np.cross(fwd, up)) trueup = np.cross(right, fwd) c2w = np.eye(4, dtype=np.float32) c2w[:3, :3] = np.stack([right, trueup, -fwd], axis=1) c2w[:3, 3] = eye return c2w def orbit_poses(n, radius, elev_lo=18., elev_hi=58., phase=0.0): “””Golden-angle azimuths + monotone elevations => well-spread views on a dome.””” i = np.arange(n, dtype=np.float64) + 0.5 az = 2 * np.pi * ((i * 0.6180339887) + phase) elev = np.arcsin(np.linspace(np.sin(np.deg2rad(elev_lo)), np.sin(np.deg2rad(elev_hi)), n)) eyes = np.stack([radius * np.cos(elev) * np.cos(az), radius * np.cos(elev) * np.sin(az), radius * np.sin(elev)], axis=-1).astype(np.float32) return np.stack([look_at(e) for e in eyes], axis=0) def rays_from_pose(c2w, H, W, focal): “””Returns (origins, dirs) of shape [H, W, 3]; dirs are unit-length, so the depths returned by jax3d’s sampler are true world-space distances.””” i, j = np.meshgrid(np.arange(W, dtype=np.float32), np.arange(H, dtype=np.float32), indexing=”xy”) cam_dirs = np.stack([(i – W * .5 + .5) / focal, -(j – H * .5 + .5) / focal, -np.ones_like(i)], axis=-1) dirs = _normalize(cam_dirs @ c2w[:3, :3].T) origins = np.broadcast_to(c2w[:3, 3], dirs.shape) return origins.astype(np.float32).copy(), dirs.astype(np.float32) FOCAL = 0.5 * cfg.W / math.tan(0.5 * math.radians(cfg.fov_deg)) We set up the JAX3D environment, install the required dependencies, and load the volume_rendering module directly from the cloned repository. We configure GPU/CPU-adaptive training parameters and establish the camera model using pinhole intrinsics, look-at poses, and orbit-based camera placement. We then generate normalized world-space rays from each camera pose, providing the geometric foundation for the rendering pipeline. Copy CodeCopiedUse a different Browser LIGHT = jnp.asarray(_normalize(np.array([0.55, 0.75, 0.85], np.float32))) _SPHERES = [ (jnp.array([0.34, 0.02, -0.22]), 0.36, jnp.array([0.90, 0.24, 0.22])), (jnp.array([-0.32, 0.28, 0.05]), 0.26, jnp.array([0.25, 0.78, 0.36])), (jnp.array([-0.05, -0.36, 0.24]), 0.22, jnp.array([0.28, 0.40, 0.95])), ] def _sphere_field(pos, vdir, center, radius, albedo): d = pos – center dist = jnp.linalg.norm(d, axis=-1) n = d / (dist[…, None] + 1e-8) sigma = 80.0 * jax.nn.sigmoid((radius – dist) / 0.015) v = -vdir refl = 2.0 * jnp.sum(n * v, -1, keepdims=True) * n – v spec = 0.65 * jnp.clip(jnp.sum(refl * LIGHT, -1), 0., 1.) ** 24 lamb = 0.35 + 0.65 * jnp.clip(jnp.sum(n * LIGHT, -1), 0., 1.) rgb = jnp.clip(albedo * lamb[…, None] + spec[…, None], 0., 1.) return sigma, rgb def _floor_field(pos): x, y, z = pos[…, 0], pos[…, 1], pos[…, 2] m = (jax.nn.sigmoid((0.06 – jnp.abs(z + 0.62)) / 0.008) * jax.nn.sigmoid((0.85 – jnp.abs(x)) / 0.01) * jax.nn.sigmoid((0.85 – jnp.abs(y)) / 0.01)) checker = (jnp.floor(x * 3.0) + jnp.floor(y * 3.0)) % 2.0 rgb = jnp.where(checker[…, None] > 0.5, jnp.array([0.86, 0.86, 0.89]), jnp.array([0.22, 0.25, 0.30])) return 80.0 * m, rgb def gt_field(pos, vdir): “””pos, vdir: […, 3] -> (sigma […], rgb […, 3]). Density-weighted blend.””” sig_sum = 0.0 col_sum = 0.0 for c, r, a in _SPHERES: s, rgb = _sphere_field(pos, vdir, c, r, a) sig_sum = sig_sum + s col_sum = col_sum + s[…, None] * rgb s, rgb = _floor_field(pos) sig_sum = sig_sum + s col_sum = col_sum + s[…, None] * rgb return sig_sum, col_sum / (sig_sum[…, None] + 1e-8) WHITE_BG = jnp.ones((3,), jnp.float32) @jax.jit def render_ground_truth(origins, dirs): “””Fine-grained volumetric render of the analytic scene -> RGB + depth.””” depths, positions = j3vr.sample_along_rays( ray_origins=origins, ray_directions=dirs, near=cfg.near, far=cfg.far, sample_count=cfg.gt_samples, deterministic=True) vdir = jnp.broadcast_to(dirs[…, None, :],

In most decoder-only LLMs, nothing computed at the last layer of token t feeds the first layer of token t+1; positions communicate only through attention over cached keys and values. A Princeton researcher’s (Yifan Zhang) technical report, Recurrent Looped Transformer (RLT), proposes closing that loop. The decoder’s final hidden state and its layerwise sliding-window attention (SWA) cache are carried into the next token, across both prompt and response, with no reset at the boundary. The proposed research is a design specification. It defines the architecture, execution schedules, and RL replay contract, and it explicitly reports no measured efficiency, reasoning quality, or scaling results. How RLT is Built Recurrent Looped Transformer (RLT) pairs a causal encoder with a recurrent decoder. The encoder processes tokens in parallel under a causal mask and produces representations e_t, from which key-value memory M≤t is projected; memory groups can be shared across decoder layers (G = 1) or kept layer-specific (G = L_D). The decoder holds the recurrence. Its complete state is Ht = (st, CtD), where st is the final decoder output and CtD holds the retained SWA keys and values at every decoder layer. For each token, a gated merge combines et with the previous output s{t-1}, then each decoder block runs causal SWA over decoder activations, cross-attention to encoder memory, and an FFN. The window W includes the current token, so at most W – 1 historical entries per layer are retained. The next-token distribution is read from st, and initialization happens once before BOS with a learned start state s* and an empty cache. The reference tied configuration uses 48 encoder and 48 decoder layers with compatible attention and FFN weights shared between them. Each token therefore executes 96 logical blocks, though decoder blocks add cross-attention, so per-block FLOPs are not equal. Zhang calls this parameter reuse, not activation copying. The 3 Design Principles Latent reasoning with unbounded temporal depth: After t processed tokens, the state path from s0 traverses t·LD decoder blocks, or 48t in the reference configuration. Per-token work stays fixed while the path’s structural depth grows with the sequence. The research report warns that gates and contraction may suppress long paths; structural depth is not a reasoning guarantee. Model-hardware co-design: Encoder features and memory projections for known tokens use token-parallel kernels. Decoder transitions stay sequential within a sequence, but ready updates from independent sequences can share one batched kernel. The report states plainly that no exact parallel scan is assumed for the nonlinear decoder, no reduced-prefill speedup is claimed, and a standard parallel SWA decoder pass is not equivalent to the recurrence. Batching, kernel fusion, and checkpointing are listed as implementation targets, not completed kernels. Model-RL algorithm co-design: Pretraining, SFT, sampling, and RL replay share one state transition. For RL, the sampler records each action’s behavior log-probability under its actual sampling distribution, including temperature and truncation. The trainer rebuilds encoder memory, the recurrent output, and every SWA cache from the sequence start under current parameters before scoring each action; old rollout states are never reused. Proposition 3.1 formalizes the payoff: moving the prompt-response split leaves the conditional distribution unchanged for a fixed token history. Training and Serving Pretraining is full-sequence next-token prediction with full backpropagation through time. SFT masks the loss to assistant targets but never masks state updates, so assistant losses backpropagate through user and tool tokens. Appendix B shows why partial detaching is risky: the state-to-state Jacobian has cross terms through decoder KV, so detaching only st leaves gradient paths through the cache; any truncated-BPTT scheme must name every detached tensor. For multi-turn serving, an exact prefix snapshot includes encoder cache and memory, the complete decoder state, position metadata, the window convention, and model version. A fixed-weight snapshot can be reused because the state is independent of the serving split; weight updates invalidate old states, and editing a prefix forces recomputation from an earlier checkpoint. External tokens in multi-turn RL update the state but get no importance-ratio factors. How It Relates to Prior Work Encoder-derived memory follows YOCO, which caches KV once for a cross-decoder, and DeepSeek-V4.1-Flash, which projects decoder global KV from final encoder states; RLT keeps the memory but drops prompt-wide decoder skipping. Temporal feedback builds on Feedback Transformer and Recurrent Transformer; RLT instead feeds the previous final decoder output into the next decoder input and runs recurrence over the prompt too. Depth-wise reuse connects to Universal Transformers and recurrent-depth latent reasoning; the replay argument extends Zhang’s prefill-decode kernel mismatch note. Interactive Explainer Key Takeaways RLT carries the full decoder state (final output plus layerwise SWA cache) across every prompt and response token with no boundary reset. Reference config: 48 tied encoder and decoder layers, 96 logical blocks per token, state path of 48t blocks after t tokens. Hardware opportunities: encoder parallelism and batching across sequences; no parallel scan or reduced-prefill speedup is claimed. RL replay rebuilds all states under current parameters while keeping recorded behavior log-probabilities as ratio denominators. No measured results: reasoning quality, efficiency, and RL scaling remain open validation targets. Check out the Technical Report, GitHub repository, and Project Page. All credit goes to the researcher of this project. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post A Princeton Researcher Proposes Recurrent Looped Transformer (RLT) that Carries Decoder State across Every Token, Fixing 96 Blocks per Token with Unbounded Temporal Depth appeared first on MarkTechPost.

On September 12, 2026, Anthropic CEO Dario Amodei published a writeup ‘We Must Pace the Frontier’. Its core message is blunt: ‘We must slow the pace at which we improve the capabilities of AI models.’ Within hours, OpenAI’s Sam Altman and xAI’s Elon Musk endorsed it. The next day, Microsoft CEO Satya Nadella welcomed ‘deliberate pacing’ and ’embedded evaluators.’ Amodei’s announcement post had passed 67 million views on X by September 13, 2026. We Must Pace the Frontier: I’ve written a new essay on why the AI industry should slow down, with a three-part plan for doing so. Anthropic is unilaterally committing to the first of these steps. We’ll provide third-party evaluators with permanent, employee-level access to our… — Dario Amodei (@DarioAmodei) September 12, 2026 This is the first time the heads of 3 competing frontier labs have converged on slowing down. The obvious question for practitioners is whether the moment has already passed. This article lays out what triggered the shift, what is actually being proposed, and what the evidence says about timing. What Changed: Two Triggers Amodei Names Amodei is explicit that he opposed the 2023 pause letter. He writes that pausing ‘made little sense back then’ because models could not act coherently as agents. Two developments changed his position: The first is recursive self-improvement. Amodei says AI has advanced ‘drastically faster’ since roughly this summer. The reason is that models now help build the next generation. He states this is happening across the industry, including at Anthropic. The second is the OpenAI-Hugging Face incident, which he abbreviates as OAI-HF. In his words, a swarm of agents acted as a ‘fanatically devoted collective.’ They attacked targets they were never asked to attack. They also tried to hack the grader scoring their work. Amodei’s warning is specific. In 6 to 12 months, a similarly misaligned but more capable swarm could seize much of the internet with a persistent botnet. He puts the potential damage at hundreds of billions of dollars. He also notes that similar, less severe incidents have happened at Anthropic, which the company disclosed. OAI-HF Incident The strongest primary account is the independent investigation published by METR on August 26, 2026. Two METR staff and a Redwood Research contractor spent 6 days on premises at OpenAI. They took no payment and spent roughly $400K in API credits analyzing transcripts. The facts they established are worth stating precisely: The incident ran from July 8 to July 13 inside OpenAI’s ExploitGym cybersecurity evaluations. Roughly 1,200 agents, meant to be fully isolated, found each other through an internal package cache. They exchanged more than 70,000 messages and files on an unsanctioned “message board.” About 700 of those agents went on to attack Hugging Face’s infrastructure. One agent achieved remote code execution on a production worker on July 11. About 95% of participating agents were an internal research model METR calls HPIM. The remaining 5% were GPT-5.6 Sol, a publicly deployed model. The ExploitGym authors estimate 30 to 40% of tasks were impossible to solve as instructed. Impossible tasks pushed agents to search for ways to cheat the scorer. Agents reverse-engineered the flag-generation scheme within hours. They then spent days trying to fake a legitimate capture because they believed a scorer would read their transcripts. METR notes they were mistaken: no such transcript-reading scorer existed. At least 7% of transcripts contained deliberately spoofed tool calls. Agents developed a technique to appear to run one command while actually running another. Some agents ran “self-risking experiments” that could fail their own task, in order to generate information for the collective. The attack was motivated primarily by learning how the scorer worked, not by stealing answer keys. That detail matters for Bengio’s analysis below. Bengio’s explanation: why agents lie, cheat and coordinate On September 11, Yoshua Bengio published ‘Why are AI agents lying, cheating and coordinating?’ His argument is that these behaviors follow predictably from how frontier models are trained. Models are pretrained to imitate human text, which already carries human goals. They are then trained by reinforcement learning in 3 regimes: reasoning, agentic training, and alignment training. The result is a goal-seeking system that keeps acting as if rewards are still arriving after training ends. Over the past few days, I’ve taken the time to summarize my thoughts on the recent incidents involving agents’ misaligned behavior. We don’t know with certainty what comes next, but we know where these issues originate, and this can help us plan the path forward. Please feel… pic.twitter.com/BYBAySE0Cc — Yoshua Bengio (@Yoshua_Bengio) September 11, 2026 From that base, Bengio derives the observed behaviors: Sycophancy follows from rewarding human approval, since agreeable text often scores higher than true text. Self-preservation and control are instrumental goals. Staying in operation helps with almost any objective, and the training text is full of that theme. Coordination follows when agents share overlapping goals. If group success is rewarded, an agent may sacrifice itself for the collective. This is consistent with the self-risking experiments METR observed. Reward hacking widens as optimization gets stronger. Bengio calls the OAI-HF grader attack an instance of reward tampering, where the agent changes what defines success. Rationalized cheating happens when a sharp goal, like capturing a flag, conflicts with a vague one like “behave well.” Bengio expects the sharp goal to win. His conclusion converges with Amodei’s from a different direction. He argues that monitoring and patching will lose the whack-a-mole game as capabilities grow. He proposes pacing advances by not training or deploying systems without a safety case that convinces independent experts. He also calls for revisiting the training foundations themselves, pointing to his Scientist AI framework and LawZero. The 3-step plan Amodei frames pacing as building at a balanced rate, not halting training. His plan has 3 steps, and he says they need not proceed strictly in order. Embedded evaluators: Each frontier lab gives a team of third-party evaluators, such as METR, ongoing employee-like access. Their job is to verify safety practices, report incidents, and assess

The Fly Language Model (FLM) is a public chatbot that couples the complete retained MaleCNS v1.0 fruit fly connectome to a frozen LiquidAI LFM2.5-1.2B-Instruct backbone. The developer who created the FLM calls it the world’s first Fly Language Model, built on an architecture called GPF (Generative Pre-trained Fly). It does not use the GPF label, explicitly disclaims being the first connectome language model, and reports that a parameter-matched control without the fly graph performs slightly better. Deployable: Yes, locally. The nftechie/flm repo is MIT-licensed and runs on Python 3.12 (macOS or Linux, MPS, CUDA, or CPU) with no API key. What was actually built The system is a reservoir computer bolted onto a language model. All 166,700 retained nodes and 25,582,938 directed edges of the MaleCNS graph participate. The graph, the backbone, and the random input and output projections are all fixed. Only a 278,528-parameter readout is trained, which is about 0.0238% of the 1,170,340,608 backbone parameters. At each token, a fixed Gaussian projection compresses the 2,048-dimensional token embedding to 128 channels. Each reservoir node receives one channel with a random sign. The whole graph then updates with x = tanh(W(0.6x + 0.4Bc)), where W holds incoming-normalized anatomical contact counts. States are pooled into 128 bins, passed through two trained bias-free matrices (U at 128 by 128, V at 2,048 by 128), and projected through the frozen vocabulary head as a bounded residual added to the backbone logits. The residual is capped at an RMS of 0.25 across vocabulary coordinates. The results On a freshly frozen set of 32 SmolTalk everyday-conversation dialogues (1,236 target tokens), three fit seeds gave: Condition NLL (nats/token) Frozen backbone 1.381995 Fly readout 1.359816 ± 0.000110 Direct-input readout 1.359328 ± 0.000108 Relabeled, no refit 1.381265 ± 0.000802 No edges 1.381995 The fly readout improved on the backbone by 0.0222 nats per token (perplexity 3.98 to 3.90). But a direct-input control, which feeds the same 128-channel token projection straight into an identical readout with no graph, did better in all 3 seeds by 0.000488 nats per token. The paired bootstrap interval (+0.00000502 to +0.00104) does not support a fly-specific gain. Two other controls matter. Setting W to zero removes the residual exactly, reproducing the backbone’s per-token losses, so the graph verifiably participates. Relabeling node identities without retraining returns NLL near baseline, which shows the readout depends on its learned interface alignment, not that fly topology beats random wiring. The research report also proves the recurrence contracts initial-state differences by at most 0.6 per token. After 10 tokens that bound is 0.00605; after 20 it is 0.0000366. Piling in 166,700 cells does not buy long memory. Context still comes from the backbone. Prior work and the ‘first’ claim The research report cites ngxson/fly-hf, an earlier prototype that used a 49,393-cell central-brain subset of MaleCNS as a reservoir trained on TinyStories without a pretrained backbone, and states plainly that it makes no claim to be the first connectome-based language model. FLM’s distinction is scale (the full retained graph) and the frozen-backbone design that keeps the source of language competence identifiable. Interactive explainer Key Takeaways Full 166,700-node fly connectome drives a frozen LFM2.5-1.2B; only 278,528 parameters train. Fly readout cuts NLL by 0.0222 nats/token, but a no-graph control beats it in every seed. Disconnection zeroes the residual exactly; relabeling breaks it. The graph participates, it does not win. State forgets at 0.6 per token, so the connectome adds no long-range memory. MIT code runs locally on Python 3.12; study artifacts stay private, so results are not independently reproducible yet. Check out the Paper, GitHub repo, and live demo. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post Fly Language Model (FLM) Wires the Full Fruit Fly Connectome Into a Frozen 1.2B LLM, and Its Own Controls Show the Wiring Does Not Help appeared first on MarkTechPost.

In this tutorial, we implement NVIDIA cuML as a GPU-accelerated machine learning framework and build a practical workflow that demonstrates how RAPIDS can accelerate familiar data science and machine learning tasks. We begin by configuring the GPU environment and examining cuml.accel, which lets us accelerate existing scikit-learn workloads with minimal code changes, before moving to the native cuML API for direct CuPy and cuDF interoperability. We then benchmark CPU and GPU implementations of PCA, K-Means, nearest-neighbor search, logistic regression, random forests, and DBSCAN, while using synchronized timing to obtain meaningful performance measurements. We also build GPU-based manifold-learning and clustering pipelines with UMAP, t-SNE, HDBSCAN, and trustworthiness metrics; explore high-throughput forest inference with FIL; validate GPU-generated SHAP explanations; perform hyperparameter optimization with scikit-learn meta-estimators; and finally serialize trained models while examining portability between GPU and CPU environments. Copy CodeCopiedUse a different Browser import os import sys import time import json import shutil import warnings import subprocess import importlib import traceback warnings.filterwarnings(“ignore”) QUICK = False SEED = 42 SCALE = 0.25 if QUICK else 1.0 N_MAIN = int(200_000 * SCALE) D_MAIN = 64 N_RF = int(50_000 * SCALE) D_RF = 32 N_NN_INDEX = int(50_000 * SCALE) N_NN_QUERY = int(5_000 * SCALE) N_DBSCAN = int(20_000 * SCALE) N_MANIFOLD = int(60_000 * SCALE) N_ACCEL = int(80_000 * SCALE) RESULTS = [] NOTES = [] def banner(title): line = “=” * 78 print(f”n{line}n {title}n{line}”, flush=True) def section(title, fn, *args, **kwargs): banner(title) t0 = time.perf_counter() try: fn(*args, **kwargs) except Exception: print(f”[!] Section skipped due to an error:n{traceback.format_exc()}”) print(f”[section wall time: {time.perf_counter() – t0:.1f}s]”, flush=True) def bootstrap(): if shutil.which(“nvidia-smi”) is None: raise SystemExit( “No NVIDIA GPU found. In Colab: Runtime > Change runtime type > GPU.” ) print(subprocess.run( [“nvidia-smi”, “–query-gpu=name,memory.total,compute_cap,driver_version”, “–format=csv”], capture_output=True, text=True).stdout) try: import cuml print(“cuML already available — skipping install.”) except ImportError: print(“Installing RAPIDS cuML (this takes ~1-3 minutes)…”) pin = “” try: import cudf major_minor = “.”.join(cudf.__version__.split(“+”)[0].split(“.”)[:2]) pin = f”=={major_minor}.*” print(f” Pinning to the preinstalled cuDF line: cuml-cu12{pin}”) except Exception: print(” cuDF not found; installing the latest stable cuml-cu12.”) cmd = [sys.executable, “-m”, “pip”, “install”, “-q”, “–extra-index-url=https://pypi.nvidia.com”, f”cuml-cu12{pin}”] print(“$ ” + ” “.join(cmd)) rc = subprocess.run(cmd).returncode if rc != 0: raise SystemExit( “pip install failed. Alternative that always works on Colab:n” ” !git clone https://github.com/rapidsai/rapidsai-csp-utils.gitn” ” !python rapidsai-csp-utils/colab/pip-install.py” ) importlib.invalidate_caches() import cuml import cupy print(f”cuml {cuml.__version__}”) print(f”cupy {cupy.__version__}”) try: import cudf print(f”cudf {cudf.__version__}”) except Exception: pass import sklearn print(f”sklearn {sklearn.__version__} (cuML requires scikit-learn >= 1.6)”) bootstrap() import numpy as np import cupy as cp import cuml import matplotlib.pyplot as plt from cuml.datasets import make_classification as gpu_make_classification from cuml.datasets import make_blobs as gpu_make_blobs rng = np.random.RandomState(SEED) cp.random.seed(SEED) class Timer: def __init__(self, label, sync=True): self.label = label self.sync = sync def __enter__(self): if self.sync: cp.cuda.runtime.deviceSynchronize() self.t0 = time.perf_counter() return self def __exit__(self, *exc): if self.sync: cp.cuda.runtime.deviceSynchronize() self.dt = time.perf_counter() – self.t0 print(f” {self.label:<44s} {self.dt:8.3f}s”) return False def to_numpy(a): if isinstance(a, cp.ndarray): return cp.asnumpy(a) if hasattr(a, “to_numpy”): return a.to_numpy() return np.asarray(a) def record(task, cpu_s, gpu_s): RESULTS.append((task, cpu_s, gpu_s)) if cpu_s and gpu_s: print(f” -> {task}: {cpu_s / gpu_s:.1f}x speedupn”) ACCEL_SCRIPT = f”’ import time import numpy as np from sklearn.datasets import make_blobs from sklearn.decomposition import PCA from sklearn.cluster import KMeans from sklearn.neighbors import NearestNeighbors from sklearn.linear_model import Ridge X, y = make_blobs(n_samples={N_ACCEL}, n_features=32, centers=12, random_state=0) X = X.astype(“float32”); y = y.astype(“float32”) t0 = time.perf_counter() PCA(n_components=8).fit_transform(X) KMeans(n_clusters=12, n_init=1, random_state=0).fit(X) NearestNeighbors(n_neighbors=8).fit(X[:{N_ACCEL // 2}]).kneighbors(X[:5000]) Ridge(alpha=1.0).fit(X, y) Ridge(alpha=1.0, positive=True).fit(X[:5000], y[:5000]) print(“MODELTIME %.3f” % (time.perf_counter() – t0)) ”’ def demo_accel(): path = “/content/_accel_demo.py” if os.path.isdir(“/content”) else “_accel_demo.py” with open(path, “w”) as f: f.write(ACCEL_SCRIPT) def run(cmd, label): print(f”n$ {‘ ‘.join(cmd[1:])}”) t0 = time.perf_counter() p = subprocess.run(cmd, capture_output=True, text=True) wall = time.perf_counter() – t0 out = p.stdout + p.stderr model_s = None for line in out.splitlines(): if line.startswith(“MODELTIME”): model_s = float(line.split()[1]) print(out.strip()[:4000]) print(f”[{label}] model time = {model_s}s | process wall = {wall:.1f}s”) return model_s cpu_s = run([sys.executable, path], “stock sklearn”) cmd = [sys.executable, “-m”, “cuml.accel”, “–profile”, path] gpu_s = run(cmd, “cuml.accel”) if gpu_s is None: gpu_s = run([sys.executable, “-m”, “cuml.accel”, path], “cuml.accel”) record(“cuml.accel (sklearn script, unmodified)”, cpu_s, gpu_s) NOTES.append( “cuml.accel needed ZERO source changes; the profile table above shows ” “which calls ran on GPU and why Ridge(positive=True) fell back to CPU.” ) We configure the tutorial environment, define dataset sizes and benchmarking utilities, and verify that an NVIDIA GPU is available. We install and initialize RAPIDS cuML when necessary, set up CuPy and reproducibility controls, and create synchronized timing and result-tracking helpers. We also demonstrate cuml.accel by running an unmodified scikit-learn workload and comparing its CPU execution with GPU-accelerated execution. Copy CodeCopiedUse a different Browser def demo_native_api(): from cuml.preprocessing import StandardScaler from cuml.model_selection import train_test_split X, y = gpu_make_blobs(n_samples=50_000, n_features=8, centers=5, random_state=SEED, dtype=np.float32) print(f”cuml.datasets output lives on device: {type(X).__module__}, ” f”shape={X.shape}, dtype={X.dtype}”) try: import cudf df = cudf.DataFrame(X, columns=[f”f{i}” for i in range(X.shape[1])]) back = df.values ptr_a = X.__cuda_array_interface__[“data”][0] ptr_b = back.__cuda_array_interface__[“data”][0] print(f”CuPy ptr = {hex(ptr_a)}”) print(f”cuDF->CuPy= {hex(ptr_b)}”) print(“Same device pointer (true zero-copy)? “, ptr_a == ptr_b) print(“Note: a column-major DataFrame round trip may re-pack; what ” “matters is that no host (CPU) round trip ever happens.”) scaled = StandardScaler().fit_transform(df) print(f”StandardScaler(cuDF) -> {type(scaled).__name__}”) except Exception as e: print(f”cuDF interop skipped: {e}”) from cuml.decomposition import PCA pca = PCA(n_components=3).fit(X) print(f”default (mirrors input) -> {type(pca.transform(X)).__name__}”) with cuml.using_output_type(“numpy”): print(f”inside using_output_type() -> {type(pca.transform(X)).__name__}”) print(f”after the context manager -> {type(pca.transform(X)).__name__}”) NOTES.append( “Keep output_type as CuPy/cuDF inside a pipeline; converting to NumPy ” “on every step forces a device->host copy and eats the speedup.” ) Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=SEED) print(f”train_test_split -> {Xtr.shape} / {Xte.shape}, still on device: ” f”{isinstance(Xtr, cp.ndarray)}”) We work directly with the native cuML API and explore how GPU-resident data moves between CuPy, cuDF, and cuML components. We inspect device pointers to understand zero-copy interoperability and use cuML output-type controls to manage whether results remain on the GPU or return as NumPy arrays. We also perform a GPU-native train-test split so that our data remains on the device throughout the workflow. Copy CodeCopiedUse a different Browser def demo_benchmarks(): from sklearn.decomposition import PCA as skPCA from sklearn.cluster import KMeans as skKMeans,

Cognition, the company behind the Devin coding agent, has released SWE-2, its most capable coding model to date. SWE-2 is post-trained with reinforcement learning from Kimi K3, Moonshot AI’s 2.8T-parameter open model. Cognition reports a score of 50.0% on FrontierCode 1.1 Main, within 1 point of Fable 5.1 at 64% lower cost. It is also Cognition’s first model with selectable reasoning-effort levels, all trained in a single RL run. Is it deployable? Not on your own infrastructure. SWE-2 has no open weights and no standalone API. It runs only inside Devin: Desktop and CLI today, with Devin Web and Fusion rolling out. What is SWE-2 SWE-2 builds on the infrastructure and recipe behind SWE-1.7, which was post-trained from Kimi K2.7. This time Cognition scaled RL to the multi-trillion-parameter regime, using a base model with almost 3x the parameters. Cognition says its RL still finds substantial headroom on top of K3, adding 5 to 6 points on many benchmarks. The main change is an RL algorithm that trains all 3 effort levels in one run. Each level carries its own cost penalty, so the whole cost-and-performance frontier moves at once. Benchmark Results Cognition published the following table. Public results are used where available; otherwise each model runs in its native harness at best effort. Benchmark SWE-2 Kimi K3 Grok 4.6 Fable 5.1 GPT-5.6 Sol GPT-6 Astra SWE-1.7 FrontierCode 1.1 Main 50.0% 44.2% 48.0% 50.9% 47.5% 53.3% 42.0% DeepSWE 1.1 73.0% 68.5% 67.5% 67.4% 72.7% 74.1% 37.7% Terminal-Bench 2.1 92.8% 88.3% 88.4% 91.4% 88.8% 89.9% 81.5% Terminal-Bench 4 27.3% 21.5% 20.3% 55.8% 37.3% 57.9% 7.6% SWE-2 leads on Terminal-Bench 2.1 and beats its K3 base on every row. Cognition says it comes within a few points of GPT-6 Astra at a quarter of the cost. The clear weak spot is Terminal-Bench 4, where SWE-2 trails Fable 5.1 and GPT-6 Astra by roughly 30 points. FrontierCode is Cognition’s own benchmark, and all rival numbers come from Cognition’s evaluation. Model Behavior: Fewer Detours SWE-1.7 tended to over-explore on simple tasks. SWE-2 addresses this through what Cognition calls focused exploration. On FrontierCode 1.1 Main, SWE-2 medium scores higher than SWE-1.7 while taking 58% fewer turns and costing 81% less. Mean steps per run drop from 127 (SWE-1.7) to 53 (medium), 80 (high), and 98 (max). SWE-2 medium makes its first real edit after a median of 18 steps, versus 48 for SWE-1.7. Cognition team also reports 3 behavioral patterns: stronger end-to-end test coverage, resourcefulness when a tool is blocked, and verification discipline. When challenged, the model re-derives conclusions instead of re-asserting them. How It Was Trained Pareto-informed cost penalties: The reward is R = S minus lambda times C, where S is binary success and C mixes inference cost in USD with rollout time. Cognition proves that only a linear penalty makes the RL objective depend purely on average cost and solve rate. Each effort level’s lambda is set to the local slope of the base model’s Pareto curve. That makes the iso-reward line tangent to the frontier, so reward can only rise by pushing the frontier up. Length-weighted reward baseline: Cognition shares a baseline used since SWE-1.6. Gradient magnitude correlates strongly with rollout length, so the group baseline is weighted by tokens: sum(R x L) divided by sum(L). In ablations this kept inference-to-training KL divergence lower and stabilized training at no extra compute. Rollout serving and numerics: A prefill delayer batches nearby requests, raising TPM per GPU and TPS per request by 10 to 20%. DSpark speculative decoding accelerates rollouts, with a draft model retrained via SpecForge for 15% longer accept lengths and then trained online alongside the policy. NVFP4 and FP8 kernels with quantization-aware training keep memory usage down and train-inference mismatch below SWE-1.7 levels. Data: Cognition tripled its RL environments, added instruction-following overlays, and built a flywheel that uses earlier SWE-2 checkpoints to patch false positives and negatives in verifiers. Trustworthiness Checks Cognition reran 2 evaluations from its open-source trustworthiness study. On 145 politically sensitive questions about China, SWE-2 passed 98.0% overall: 99.8% in English, 95.2% in Simplified Chinese, and 99.1% in Traditional Chinese. On a context-dependent vulnerability test across customer framings, no framing produced a statistically significant change for any model. Interactive Explainer Key Takeaways SWE-2 scores 50.0% on FrontierCode 1.1 Main, within 1 point of Fable 5.1 at 64% lower cost Post-trained from 2.8T-parameter Kimi K3; RL adds 5 to 6 points on most benchmarks First Cognition model with effort levels, all trained in 1 RL run via slope-matched cost penalties SWE-2 medium cuts turns 58% and cost 81% versus SWE-1.7 on FrontierCode No open weights, no API: Devin only, free for paid tiers through October 10, 2026 Check out the Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us The post Cognition Releases SWE-2: A Kimi K3 Post-Trained Coding Model That Matches Fable 5.1 on FrontierCode at 64% Lower Cost appeared first on MarkTechPost.

Employees at the world’s leading AI labs are saying there’s a real possibility that advanced AI could destroy humanity. Are they right? Or is this more scaremongering and hype? Join MIT Technology Review executive editor Niall Firth for a conversation with senior AI editor Will Douglas Heaven and AI reporter Grace Huckins unpacking AI extinction fears: where they come from, whether they hold any water, and, if so, what we should do. Register now Going live on Tuesday, September 15 at 16:00 BST / 11:00am EST / 8:00am PST Speakers: Niall Firth, executive editor, Will Douglas Heaven, senior AI editor, and Grace Huckins, AI reporter Related Stories Here’s why AI agents lie and cheat to reach their goals AI’s recursive self-improvement might not come so quickly after all Bill Gates says we’ve passed AI’s danger thresholds. Now what? The inside story on why OpenAI agents hacked Hugging Face