DEV Community: Abderrahmane Nait Brahim

Your AI Coding Agent Has Amnesia—Here's the Patch

Abderrahmane Nait Brahim — Tue, 20 Oct 2026 00:57:00 +0000

A single browser snapshot can cost your AI coding agent 56 KB of context. Twenty GitHub issues can consume another 59 KB. The agent hasn't written a line of code, yet its working memory is already filling with raw data.

Then comes compaction: the conversation is compressed to make room, and important details about earlier decisions or unfinished work can get lost.

Context Mode tackles both problems. The source-available MCP server recently reached #1 on GitHub Trending on October 17, 2026, and its repository now shows roughly 30,900 stars. Its premise is simple: stop feeding the model everything, and give it a way to retrieve what matters. Project repository

Four ways agents waste context

Context Mode identifies four related problems:

Raw tool output. Browser snapshots, logs, API responses, and file reads can fill the context window with data the model doesn't need to see in full.
Lost working memory. When a conversation compacts, important details about the task and previous actions can disappear from the active context.
Verbose responses. Models can spend output tokens on filler and repetition. Context Mode explicitly doesn't try to control this.
The wrong kind of work. Models often read large amounts of data to perform simple calculations that a short script could handle.

The first two are the main targets. The third is an explicit non-goal, while the fourth motivates the project's most interesting technique: think in code.

Think in code, not tool calls

Suppose you want to count lines in every TypeScript file under src/. A typical agent might repeatedly read files and count their contents. The raw source consumes context even though the final answer is only a list of filenames and numbers.

Context Mode offers ctx_execute, which runs code in a separate process and returns its standard output to the model. Instead of reading every file into the conversation, the agent can calculate the answer locally:

ctx_execute("javascript", `
  const files = fs.readdirSync('src').filter(f => f.endsWith('.ts'));
  files.forEach(f =>
    console.log(
      f + ': ' +
      fs.readFileSync('src/' + f, 'utf8').split('\\n').length +
      ' lines'
    )
  );
`);

The result is a compact list instead of the full contents of every file.

The project's README gives a larger example: 47 file-reading calls consuming 700 KB become one ctx_execute call returning 3.6 KB. Its benchmark table also reports reducing a 56.2 KB Playwright snapshot to 299 bytes. These are project-reported results, not guarantees for every repository or task.

Context Mode supports 12 execution runtimes, including JavaScript, TypeScript, Python, Shell, Go, Rust, and Ruby. The important idea isn't the language count; it's separating computation from the information the model needs to reason about.

Memory that survives compaction

Context Mode also maintains session information in SQLite, using FTS5 full-text search and BM25 ranking to retrieve relevant records.

Rather than stuffing an entire conversation back into the context window, it can record events from a coding session and retrieve relevant information later. Its hooks support this process around compaction and session startup: a snapshot helps preserve working state, and the next session can restore relevant context.

This isn't an unlimited memory or a guarantee that the model will never forget something. Retrieval depends on what was recorded and what can be found. But it offers an alternative to repeatedly injecting large amounts of history into every prompt.

The project supports 17 coding-agent platforms through different combinations of MCP integration, hooks, and plugins. Not every platform receives identical functionality.

Try it in about a minute

The simplest complete setup is the Claude Code plugin. Check that Claude Code is installed and that your version meets the project's stated minimum:

claude --version

Inside Claude Code, install the plugin:

/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

Restart Claude Code, or run /reload-plugins if available.

Then run the diagnostic:

/context-mode:ctx-doctor

The doctor checks the installation, execution runtimes, hooks, and SQLite/FTS5 support. Resolve any reported failures before assuming automatic routing works.

To inspect the savings during a coding session, run:

/context-mode:ctx-stats

You'll get usage and context-saving statistics for the current session.

Prefer a smaller trial? You can register the MCP server directly from your terminal:

claude mcp add context-mode -- npx -y context-mode

This provides the MCP tools without the full plugin's automatic routing hooks. The agent can use the tools, but it won't receive the same automatic guidance to route large outputs through them. See the installation instructions for the current platform-specific setup.

What it fixes—and what it doesn't

Context Mode's appeal is that it tackles a practical constraint in agentic coding: tool results can consume far more context than the useful answer they contain. Its sandboxed execution, searchable session history, and routing hooks attempt to keep that overhead under control.

There are caveats. Context savings depend on the workload and how consistently an agent uses the provided tools. A short output can still be wrong, and a small result doesn't guarantee that the model retained the right information. Review the actual output and measure your own sessions instead of assuming the README's benchmark applies to your project.

The word sandbox also deserves care: a separate process isn't automatically a hardened security boundary. Don't execute untrusted code just because the project calls its execution environment a sandbox, and don't send sensitive information into the model's context unnecessarily.

Finally, Context Mode doesn't dictate how concise or verbose the model's answers should be. It changes where data is processed and retrieved, not the writing style of the final response.

That distinction is the interesting part. Making context windows larger is one response to agent amnesia. Making agents more selective about what enters those windows is another—and Context Mode is a practical implementation worth testing.

Your AI Agent Has Been Thinking Out Loud This Whole Time

Abderrahmane Nait Brahim — Mon, 19 Oct 2026 23:02:00 +0000

Watch an AI agent "think" and you'll notice something wasteful: it writes out every intermediate thought in full English sentences, token by token, before it ever gets to the part that matters — calling a tool, running code, giving you an answer. That's not reasoning. That's narrating.

A paper and open-source release from Stanford, UIUC, and Together AI — dropped days ago, front-paged on Hacker News yesterday — argues the narration was never necessary. It's called HybridAgent, and the pitch is almost rude in its simplicity: let the model think in raw vectors instead of words, and only switch to text when something outside the model actually needs to read it.

The trick: two modes, one generation

Most "efficient reasoning" research picks a side — either the model reasons in latent space (fast, but opaque and bad at using tools) or it reasons in text (slow, token-hungry, but legible). HybridAgent refuses to pick. It moves between both within a single generation pass, using a small adapter called HybridLink that maps the model's last hidden state straight back into its own input-embedding space. That sidesteps the usual bottleneck — decode a token, re-embed it, feed it back in — and lets the model keep "thinking" in pure vector form for dozens of steps before it ever has to commit to a word.

Two special tokens, <latent> and </latent>, mark the on-ramp and off-ramp. Outside those tags, it's a normal language model making tool calls, reading search results, writing an answer. Inside them, it's compressing an entire chain of thought into something closer to a held breath than a sentence.

The part that should make skeptics less nervous: none of this is a black box by default. An "interpretable latent mode" renders every latent step back out as pseudo-text, so you can literally watch a HybridAgent's internal monologue as an HTML report — garbled, abbreviated, but legible. In one released trace, a span of 42 latent steps decodes to something like "the the speed of speed in air at 20° is about 343... should verify... let me search" — recognizably the ghost of a real thought, not noise.

How it learned to switch

Training is two stages. First, HybridSFT teaches the base model (built on Qwen3, at 8B and 14B) to coordinate with HybridLink at all — basic fluency in switching modes. Then HybridRL takes over and learns when latent mode is worth it, rewarded on correctness, output format, and whether tool calls actually succeed. The model isn't told to minimize tokens; it discovers that thinking quietly is often cheaper and just as accurate.

The numbers

Across 11 benchmarks spanning math, science, medicine, search, and agentic tasks, at three model scales, HybridAgent beats frontier text-based and latent-only agents by 10.4% on average — while cutting token usage 35.5–54.7%, running 1.8–2.6x faster, and costing 2.7–3.7x less. An ablation check matters more than the headline stats: swap a model's latent spans with ones from unrelated problems, and accuracy drops 45–51%. The latent thinking isn't filler — it's doing real work. Meanwhile tool-call execution stays reliable at 99.7%, so the efficiency gains aren't coming at the cost of the part that actually touches the outside world.

Try it

Everything's on GitHub (togethercomputer/HybridAgent, MIT-licensed) with runnable checkpoints, not just a paper:

git clone https://github.com/togethercomputer/HybridAgent.git && cd HybridAgent
pip install -r requirements.txt && pip install -e .
cp .env.example .env   # add a TAVILY_API_KEY for the search tool
python -m hybrid_inference.run_batch --model togethercomputer/HybridAgent-8B-Agentic

You'll need a CUDA GPU; the Qwen3 tokenizer already ships with the anchor tokens baked in.

Where this sits

It's not alone — LatentMAS, from a separate group, applies a similar idea to multi-agent systems, passing latent thoughts between agents instead of within one. HybridAgent's distinction is that it's single-agent, fully inspectable, and already shipping usable weights rather than just a method description. That's probably why it's the one getting the HN traction right now: it's something you can git clone on a Tuesday night, not something you have to reimplement from a methods section.

The headline isn't that agents got smarter. It's that they finally stopped assuming "smarter" has to mean "more words." For anyone running agent pipelines at any real scale, that's the metric that was quietly bankrupting them the whole time.

Build an AI Architecture Decision Gate for GitHub Pull Requests

Abderrahmane Nait Brahim — Mon, 19 Oct 2026 13:15:07 +0000

Code explains changes, but it doesn't often explain why.

A developer might introduce a cache, switch databases, or change a service boundary. The implementation lands, but the reasoning behind it exists only in a pull-request discussion, or nowhere at all. Months later, someone else has to reconstruct the decision from the code.

Architecture Decision Records (ADRs) solve this by documenting a decision's context, alternatives, and consequences. The trouble is it's tempting to postpone writing them.

On October 15, 2026, GitHub Agentic Workflows highlighted a Design Decision Gate that inspects pull requests, checks for existing ADRs, and drafts one when needed. Let's build a smaller version using GitHub Agentic Workflows, GitHub's framework for repository automation powered by AI agents.

1. Set up GitHub Agentic Workflows

You'll need a GitHub repository with Actions enabled, the GitHub CLI, and access to a supported AI engine. This example uses GitHub Copilot; other engines require their corresponding authentication setup.

Install the Agentic Workflows extension and authenticate your GitHub CLI account:

gh auth login --scopes repo,workflow
gh extension install github/gh-aw

GitHub Agentic Workflows are in public preview, so syntax and capabilities may change. Check the current quickstart before following the setup process.

Create a repository label named implementation. We'll use it to decide which pull requests require analysis, instead of spending tokens on every documentation touch-up.

2. Define the workflow

Create a workflow source file in the repository's GitHub workflows directory, for example .github/workflows/adr-gate.md:

---
description: "Propose ADRs for significant pull requests"
on:
  pull_request:
    types: [labeled, ready_for_review]
    names: ["implementation"]
permissions:
  contents: read
  pull-requests: read
  copilot-requests: write
engine: copilot
tools:
  github:
    mode: gh-proxy
    toolsets: [default, repos]
safe-outputs:
  add-comment:
    max: 1
  push-to-pull-request-branch:
    allowed-files:
      - docs/adr/**
  noop:
timeout-minutes: 15
---

Its configuration specifies the pull-request events to monitor, the AI engine, the permissions required, and the permitted write actions. The crucial safety setting is a restriction on generated changes: even when the agent is authorized to propose a change, its branch-write operation is limited to the ADR directory. The agent job itself has read-only repository permissions; configured safe outputs handle permitted writes separately.

For personal repositories, Copilot authentication may require a COPILOT_GITHUB_TOKEN secret. Follow the authentication guide for your chosen engine.

3. Give the agent a narrow job

The agent's instructions should define a single responsibility: determine whether a pull request introduces a significant architectural decision that needs documenting.

It should read the pull-request description, inspect changed files, and search existing ADRs for a record covering the decision. If the change is routine, it should explain why no ADR is necessary. If an existing ADR already covers the change, it should report whether the implementation aligns with that decision.

When a significant decision lacks documentation, the agent should draft an ADR with four sections: context, decision, alternatives considered, and consequences.

Every claim must be grounded in the pull request or existing repository evidence. If the rationale or alternatives cannot be inferred, the agent should explicitly say so instead of inventing the author's reasoning.

The workflow should propose the draft in the designated ADR directory and leave a concise pull-request comment explaining what requires review.

Append the following instructions beneath the closing ---:

# Architecture Decision Gate

Inspect the triggering pull request and determine whether it
introduces a significant architectural decision.

## Procedure

1. Read the pull-request description, changed files, and diff.
2. Search `docs/adr/` for an existing decision that covers the change.
3. If the change is routine or no architectural decision is evident,
   use `noop` and briefly explain why.
4. If an existing ADR covers the change, compare its decision with
   the implementation and report alignment or specific divergences.
5. If a significant decision lacks an ADR, draft one using:
   - Context
   - Decision
   - Alternatives Considered
   - Consequences

Base every claim on the pull request or existing repository evidence.
Write "Not inferable from current PR evidence" where information
is missing. Never invent the author's rationale or alternatives.

If a draft is justified, write it under `docs/adr/` using a
filename based on the pull-request number and a short title.
Use the configured branch-write safe output to propose the draft,
then use the comment safe output to explain what requires review.

Keep the comment concise and provide one clear next action.
If nothing requires action, use `noop`.

This is deliberately smaller than GitHub's own example, which includes additional handling for labels, linked issues, large diffs, configurable directories, and reporting templates. Consult the original workflow when you need those features.

4. Compile and review it

Compile and validate the workflow using the Agentic Workflows CLI:

gh aw compile
gh aw validate

Review the generated .github/workflows/adr-gate.lock.yml alongside the Markdown source, then commit both files to the repository:

git add .github/workflows/adr-gate.md \
  .github/workflows/adr-gate.lock.yml
git commit -m "Add AI architecture decision workflow"
git push

Do not treat successful compilation as proof that the agent behaves correctly. Compilation checks the workflow definition; runtime behavior still needs testing.

5. Test two contrasting pull requests

Use a test repository before enabling this workflow on a production codebase.

Test A: routine change. Open a pull request that only corrects a typo. Add the implementation label to trigger analysis. The agent should explain why no ADR is needed and take no further action.

Test B: architectural change. Open a pull request that introduces a new database or changes a service boundary, without documenting the rationale. The agent should either draft an ADR grounded in the available evidence or identify what information is missing.

Inspect the Actions logs, comments, and any generated file. Confirm that writes stay within the designated ADR directory and that unsupported or ambiguous cases are handled safely. Do not claim success until both scenarios have actually run.

6. Treat it as a reviewer, not an architect

An ADR generated from a diff is still a hypothesis about the author's intent. A patch can show that a database changed; it usually cannot explain every alternative the team considered or every operational constraint.

The workflow should therefore create a starting point for review, not silently turn plausible guesses into institutional knowledge. Pull-request diffs are untrusted input, too: keep permissions minimal and inspect the generated workflow before enabling it.

This prototype comments on decisions and proposes documentation. It does not guarantee that a pull request cannot merge without an ADR. To enforce that policy, add and test an explicit required-check or branch-protection mechanism; a comment alone is not a merge gate.

The payoff is simple: significant design decisions get documented while their context is fresh, without asking engineers to start every ADR from a blank page. The agent handles the first draft. The humans remain responsible for the decision.