Author name: ITMAITY

The open source Git project just released Git 2.52 with features and bug fixes from over 94 contributors, 33 of them new. We last caught up with you on the latest in Git back when 2.51 was released. To celebrate this most recent release, here is GitHub’s look at some of the most interesting features and changes introduced since last time. Tree-level blame information If you’re a seasoned Git user, then you are no doubt familiar with git blame, Git’s tool for figuring out which commit most recently modified each line at a given filepath. Git’s blame functionality is great for figuring out when a bug was introduced, or why some code was written the way it was. If you want to know which commit last modified any portion of a given filepath, that’s easy enough to do with git log -1 — path/to/my/file, since -1 will give us only the first commit which modifies that path. But what if instead you want to know which commit most recently modified every file in some directory? Answering that question may seem contrived, but it’s not. If you’ve ever looked at a repository’s file listing on GitHub, the middle column of information has a link to the commit which most recently modified that path, along with (part of) its commit message. GitHub’s repository file listing, showing tree-level blame information. The question remains: how do we efficiently determine which commit most recently modified each file in a given directory? You could imagine that you might enumerate each tree entry, feeding it to git log -1 and collecting the output there, like so: $ git ls-tree -z –name-only HEAD^{tree} | xargs -0 -I{} sh -c ‘ git log -1 –format=”$1 %h %s” — $1 ‘ — {} | column -t -l3 .cirrus.yml 1e77de10810 ci: update FreeBSD image to 14.3 .clang-format 37215410730 clang-format: exclude control macros from SpaceBeforeParens .editorconfig c84209a0529 editorconfig: add .bash extension .gitattributes d3b58320923 merge-file doc: set conflict-marker-size attribute .github 5db9d35a28f Merge branch ‘js/ci-github-actions-update’ […] That works, but not efficiently. To see why, consider a case with files A, B, and C introduced by commits C1, C2, and C3, respectively. To blame A, we walk from C3 back to C1 in order to determine that C1 was the most recent commit to modify A. That traversal passed through C2 and C3, but since we were only looking for modifications to A, we’ll end up revisiting those commits when trying to blame B and C. In this example, we visit those three commits six times in total, which is twice the necessary number of history traversals. Git 2.52 introduces a new command which comes up with the same information in a fraction of the time: git last-modified. To get a sense for how much faster last-modified is than the example above, here are some hyperfine results: Benchmark 1: git ls-tree + log Time (mean ± σ): 3.962 s ± 0.011 s [User: 2.676 s, System: 1.330 s] Range (min … max): 3.940 s … 3.984 s 10 runs Benchmark 2: git last-modified Time (mean ± σ): 722.7 ms ± 4.6 ms [User: 682.4 ms, System: 40.1 ms] Range (min … max): 717.3 ms … 731.3 ms 10 runs Summary git last-modified ran 5.48 ± 0.04 times faster than git ls-tree + log The core functionality behind git last-modified was written by GitHub over many years (originally called blame-tree in GitHub’s fork of Git), and is what has powered our tree-level blame since 2012. Earlier this year, we shared those patches with engineers at GitLab, who tidied up years of development into a reviewable series of patches which landed in this release. There are still some features in GitHub’s version of this command that have yet to make their way into a Git release, including an on-disk format to cache the results of previous runs. In the meantime, check out git last-modified, available in Git 2.52. [source, source, source] Advanced repository maintenance strategies Returning readers of this series may recall our coverage of the git maintenance command. If this is your first time reading along, or you could use a refresher, we’ve got you covered. git maintenance is a Git command which can perform repository housekeeping tasks either on a scheduled or ad-hoc basis. The maintenance command can perform a variety of tasks, like repacking the contents of your repository, updating commit-graphs, expiring stale reflog entries, and much more. Put together, maintenance ensures that your repository continues to operate smoothly and efficiently. By default (or when running the gc task), git maintenance relies on git gc internally to repack your repository, and remove any unreachable objects. This has a couple of drawbacks, namely that git gc performs “all-into-one” repacks to consolidate the contents of your repository, which can be sluggish for very large repositories. As an alternative, git maintenance has an incremental-repack strategy, but this never prunes out any unreachable objects. Git 2.52 bridges this gap by introducing a new geometric task within git maintenance that avoids all-into-one repacks when possible, and prunes unreachable objects on a less frequent basis. This new task uses tools (like geometric repacking) that were designed at GitHub and have powered GitHub’s own repository maintenance for many years. Those tools have been in Git since 2.33, but were awkward to use or discover since their implementation was buried within git repack, not git gc. The geometric task here works by inspecting the contents of your repository to determine if we can combine some number of packfiles to form a geometric progression by object count. If it can, it performs a geometric repack, condensing the contents of your repository without pruning any objects. Alternatively, if a geometric repack would pack the entirety of your repository into a single pack, then a full git gc is performed instead, which consolidates the contents of your repository and prunes out unreachable objects. Git 2.52 makes it a breeze to keep even your largest repositories running smoothly. Check out the new geometric strategy, or

In VS Code, GitHub Copilot Chat can access hundreds of tools through the Model Context Protocol (MCP) that range from codebase analysis tools to Azure-specific utilities. But giving an agent too many tools doesn’t always make it smarter. Sometimes it just makes it slower.  If you’ve ever seen this spinner in VS Code, you’ve hit the limits of a model that’s trying to reason across too many tools at once. To fix that, we’ve built two new systems—embedding-guided tool routing and adaptive tool clustering—and we’re rolling out a reduced toolset that trims the default 40 built-in tools down to 13 core ones. Across benchmarks like SWE-Lancer and SWEbench-Verified with both GPT-5 and Sonnet 4.5, these changes improve success rates by 2-5 percentage points. In online A/B testing, it reduces response latency by an average of 400 milliseconds.   Too many tools impede agent intelligence    The default toolset in VS Code consists of about 40 built-in tools, ranging from general command-line utilities to specialized tools for Jupyter Notebooks. With MCP servers included, that number can grow into the hundreds. Often, MCP servers bring in so many tools that they can exceed the API limits of some models.   We’ve explored ways to filter down our toolset to provide only the tools most relevant to the user’s query, while not restricting the agent’s capabilities. Specifically, we needed to make sure we didn’t sacrifice the user’s experience to achieve lower latency.  To accomplish this, we designed a middle-ground approach: “virtual tools.” This includes functionally grouping similar tools under one “virtual tool” the chat agent can expand as needed. Think of these as directories that contain related tools. This gives the model a general sense of what’s available without flooding it with hundreds of tool names. It also reduces the cache miss rate we’d expect if the model searched for individual tools, since it’s likely that similar tools are used and activated together.   Applying lossless dynamic tool selection for MCP tools   Adaptive tool clustering   Initially we fed all the available tools into an LLM and asked it to group and summarize them. But this had two big issues:    We couldn’t control the number of groups created, and it sometimes exceeded model limits    It was extremely slow and incurred a huge token cost. The model would also sometimes ‘forget’ to categorize certain tools, forcing retries   To tackle this issue, we applied our internal Copilot embedding model optimized for semantic similarity tasks to generate embeddings for each tool and group them using cosine similarity. This clustering method allowed precise, stable, and reproducible groups. As an example, here is one possible grouping of embeddings for the GitHub MCP server’s tools in the embedding space:   We still use a model call to summarize each cluster, but this step is much faster and cheaper than asking the model to categorize everything from scratch. Tool embeddings and group summaries are cached locally, so recomputing them is comparatively cheap.   Context-guided tool selection   Once tools were grouped, we faced another problem: how does the model know which group to open without checking them all? We saw that, most of the time, the model would eventually find the right tool for its task. However, each call to a virtual tool still results in a cache miss, an extra round trip, and an opportunity for a small percentage of agent operations to fail.  For example, when the user says: “Fix this bug and merge it into the dev branch.”  The model often opens search tools, then documentation tools, then local Git tools, before finally realizing that it actually needs the merge tool inside the GitHub MCP tool group to complete the operation.  Each incorrect group lookup adds latency and overhead, even though the correct group is fairly obvious from the context.  To address this, we introduced Embedding-Guided Tool Routing. Before any tool group is expanded, the system compares the query embedding against vector representations of all tools (and their clusters), allowing it to pre-select the most semantically relevant candidates—even if they’re buried deep inside a group.  With context-aware routing, we can infer from the beginning that the model is very likely to need the merge tool inside the GitHub MCP tool group, and include it directly in its candidate set—eliminating unnecessary exploratory calls and significantly reducing latency and failure rates.  By surfacing only the most promising matches, we make the model’s search more targeted and reliable, while reducing redundant exploration.  Embedding-based selection (powered by the Copilot Embedding model)   We calculate the success of our embedding-based selection process via Tool Use Coverage, which measures how often the model already has the right tool visible when it needs it.  In benchmarks, the embedding-based approach achieved 94.5% Tool Use Coverage, outperforming both LLM-based selection (87.5%) and the default static tool list (69.0%).   Offline, this approach resulted in a 27.5% absolute improvement in coverage, clearly surpassing the LLM-based method while helping the agent reason faster and stay efficient.   Online testing shows the same pattern: only 19% of Stable tool calls were successfully pre-expanded using the old method, whereas 72% of Insiders tool calls were pre-expanded thanks to the embedding-based matching. This confirms that the gains observed offline are consistently reflected in real-world usage.  Less is more: shrinking the default toolset    Even without hitting the model limits that massive MCP servers can trigger, an oversized built-in toolset still degrades performance. In offline benchmarks, we observed a 2–5 percentage point decrease in resolution rate on benchmarks including SWE-Lancer when the agent had access to the full built-in toolset. Behaviorally, the agent ends up ignoring explicit instructions, using tools incorrectly, and calling tools that are unnecessary to the task at hand.   So, we trimmed the list. Based on tool usage statistics and performance data, we identified a core toolset of 13 essential tools. These tools encompass high-level repository structure parsing, file reading and editing, context searching, and terminal usage.   The remaining, non-core built-in tools are grouped into four virtual categories: Jupyter Notebook Tools, Web Interaction Tools, VS Code Workspace Tools, and Testing Tools. This way, the model sees the smaller core set up-front and can expand groups only if necessary. As a result, users with the shrunken toolset experience an average decrease of 190 milliseconds in TTFT (Time To First Token), and an average decrease of 400 milliseconds in TTFT (Time to Final Token, or time to complete model response). A smaller toolset enables the agent to be more effective: simpler reasoning, faster response times, and better performance.   Future directions: from tool selection to long-context reasoning   As MCP systems evolve, the challenge isn’t just picking the right tool—it’s reasoning across time, context, and interactions.    A truly intelligent model shouldn’t just react to queries; it should remember previous tool usage, infer intent from history, and plan multi-step actions over long sessions. In this sense, tool selection is an early form of long-context reasoning. The same mechanisms that help models route to the right tool today could, in the future, help them reason across thousands of turns helping them decide when to act, when

Editing code often involves a series of small but necessary changes ranging from refactors to fixes to cleanup and edge-case handling. In February, we launched next edit suggestions (NES), a custom Copilot model that predicts the next logical edit based on the code you’ve already written. Since launch, we’ve shipped several major model updates, including the newest release earlier this month.  In this post, we’ll look at how we built the original model, how we’ve improved it over time, what’s new, and what we’re building next.  Why edit suggestions are challenging  Predicting the next edit is a harder problem than predicting the next token. NES has to understand what you’re doing, why you’re doing it, and what you’ll likely do next. That means:  The model must respond quickly to keep up with your flow. It has to know when not to suggest anything (too many suggestions can break your focus). It must infer intent from local context alone without your explicit prompts.  It must integrate deeply with VS Code so suggestions appear exactly where you expect them. Frontier models didn’t meet our quality and latency expectations. The smaller ones were fast but produced low-quality suggestions, while the larger ones were accurate but too slow for an in-editor experience. To get both speed and quality, we needed to train a custom model.  NES isn’t a general-purpose chat model. It’s a low-latency, task-specific model that runs alongside the editor and responds in real time. It’s the result of aligning model training, prompting, and UX around a single goal: seamless editing inside the IDE. That required tight coordination between model training, prompt design, UX design, and the VS Code team—the model only works because the system was co-designed end-to-end. This “AI-native” approach where every part of the experience evolves together is very different from training a general-purpose model for any task or prompt. It’s how we believe AI features should be built: end to end, with the developer experience at the center.  How we trained  The hard part wasn’t the architecture; it was the data. We needed a model that could predict the next edit a developer might make, but no existing dataset captured real-time editing behavior.  Our first attempt used internal pull request data. It seemed reasonable: pull requests contain diffs, and diffs look like edits. But internal testing revealed limitations. The model behaved overly cautiously—reluctant to touch unfinished code, hesitant to suggest changes to the line a user was typing, and often chose to do nothing. In practice, it performed worse than a vanilla LLM.  That failure made the requirement clear: we needed data that reflected how developers actually edit code in the editor, not how code looks after review.  Pull request data wasn’t enough because it:  Shows only the final state, not the intermediate edits developers make along the way  Lacks temporal ordering, so the model can’t learn when changes happen  Contains almost no negative samples (cases where the correct action is “don’t edit”)  Misses abandoned edits, in-progress rewrites, and other common editing behavior  So we reset our approach and built a much richer dataset by performing a large-scale custom data collection effort that captured code editing sessions from a set of internal volunteers. We found data quality to be key at this stage: a smaller volume of high-quality edit data led to better models than those trained with a larger volume of data that was less curated.  Supervised fine-tuning (SFT) of a model on this custom dataset produced the first model to outperform the vanilla models. This initial model provided a significant lift to quality and served as a foundation for the next several NES releases.  Model refinement with reinforcement learning  After developing several successful NES models with SFT, we focused on two key limitations of our training approach:  SFT can teach the model what constitutes a good edit suggestion, but it cannot explicitly teach the model what makes an edit suggestion bad. SFT can effectively leverage labeled edit suggestions, but it cannot fully utilize the much larger number of unlabeled code samples. To address these two limitations, we turned to reinforcement learning (RL) techniques to further refine our model. Starting with the well-trained NES model from SFT, we optimized the model using a broader set of unlabeled data by designing a grader capable of accurately judging the quality of the model’s edit suggestions. This allows us to refine the model outputs and achieve higher model quality.  The key ideas in the grader design can be summarized as follows:  We use a large reasoning model with specific grading criteria. We routinely analyze model outputs to update the grading criteria, constantly searching for new qualities that indicate unhelpful edits. The grader should not only consider the correctness of the edit suggestion, but also strive to make the code diff displayed in the UI more user-friendly (easy to read). Continued post-training with RL has improved the model’s generalization capability. Specifically, RL extends training to unsupervised data, expanding the volume and diversity of data that we have available for training and removing the requirement that the ground truth next edit is known. This ensures that the training process consistently explores harder cases and prevents the model from collapsing into simple scenarios.  Additionally, RL allows us to define our preferences through the grader, enabling us to explicitly establish criteria for “bad edit suggestions.” This enables the trained model to better avoid generating bad edit suggestions when faced with out-of-distribution cases.  Lessons from training our latest custom NES model  Our most recent NES release builds on that foundation with improvements to data, prompts, and architecture:  Prompt optimization: NES runs many times per minute as you edit, so reducing the amount of context we send on each request has a direct impact on latency. We trimmed the prompt, reused more cached tokens between calls, and removed unneeded markup, which makes suggestions appear faster without reducing quality.  Data quality filtering: Used LLM-based graders to filter out ambiguous or low-signal samples in order to reduce unhelpful

Discover how Azure Local & Dell redefine hybrid cloud with seamless integration, flexibility, and enterprise-grade performance   ​  ​Discover how Azure Local & Dell redefine hybrid cloud with seamless integration, flexibility, and enterprise-grade performance Announcement Blog | Dell

Don’t compromise between on-premises control and cloud agility.   ​  ​Don’t compromise between on-premises control and cloud agility. Launch Blog | Dell

Automate data tasks and free wealth managers to focus on clients and deliver strategic guidance with the Augmented Advisor.   ​  ​Automate data tasks and free wealth managers to focus on clients and deliver strategic guidance with the Augmented Advisor. AI Solutions Blog | Dell

Dell drives AI innovation with policy leadership, workforce development, and cutting-edge solutions transforming communities.   ​  ​Dell drives AI innovation with policy leadership, workforce development, and cutting-edge solutions transforming communities. Government Blog | Dell

Future-proof your storage strategy with simplicity and long-term cost savings.   ​  ​Future-proof your storage strategy with simplicity and long-term cost savings. PowerStore Blog | Dell

Explore the high value QLC technology can bring to your mission-critical workloads.   ​  ​Explore the high value QLC technology can bring to your mission-critical workloads. PowerMax Blog | Dell

Humain Studios uses AI and GPUs to turn a 33-year scan cleanup challenge into a one-day NPC creation pipeline.   ​  ​Humain Studios uses AI and GPUs to turn a 33-year scan cleanup challenge into a one-day NPC creation pipeline. Dell Pro Max Blog | Dell

Run large AI models locally with datacenter-class fidelity and predictable performance, without sending sensitive data to the cloud.   ​  ​Run large AI models locally with datacenter-class fidelity and predictable performance, without sending sensitive data to the cloud. Announcement Blog | Dell

Containers are the future of app development, but stateful vs stateless? Dell PowerScale & ObjectScale have you covered. Dive in!   ​  ​Containers are the future of app development, but stateful vs stateless? Dell PowerScale & ObjectScale have you covered. Dive in! PowerScale Blog | Dell

Unlock AI’s potential in security! Discover how CTOs & CSOs can collaborate to harness AI safely and effectively. Read more!   ​  ​Unlock AI’s potential in security! Discover how CTOs & CSOs can collaborate to harness AI safely and effectively. Read more! PowerScale Blog | Dell

AI needs a better network. We’re building it with Dell Enterprise SONiC & NVIDIA Spectrum-X. See how we’re unlocking AI’s future.   ​  ​AI needs a better network. We’re building it with Dell Enterprise SONiC & NVIDIA Spectrum-X. See how we’re unlocking AI’s future. Announcement Blog | Dell

Unlock massive AI scalability with Dell PowerScale! Parallel NFS delivers faster data access, true linear scalability, and seamless deployment for your most demanding workloads.   ​  ​Unlock massive AI scalability with Dell PowerScale! Parallel NFS delivers faster data access, true linear scalability, and seamless deployment for your most demanding workloads. Announcement Blog | Dell

Unlock massive AI scalability with Dell PowerScale and pNFS. Discover how parallel data access delivers faster throughput and client level scalability to feed GPUs for model training and ML/DL workloads.   ​  ​Unlock massive AI scalability with Dell PowerScale and pNFS. Discover how parallel data access delivers faster throughput and client level scalability to feed GPUs for model training and ML/DL workloads. AI Solutions Blog | Dell