Agent-人类协作的基特堡

Agent-人类协作的基特堡

在一年多的铁锤锤之后，我们很兴奋地介绍第一个为agent人类合作建造的基特铸币。 整个建筑以三个原始人为基础：

- 拖车与使用diff审查代码更改的经典拉力请求模型不同，Trails为开发者提供类似于航空飞行员的机头显示，自动自定义的eval在每次代码推力上由agents评分。

- 分布式Git托管。 整个系统都是在兼容Git的新源控制服务器上构建的，它推进速度高达89x比GitHub快，6x比Cursor Origin快。 您可以在全球多个区域托管您的Repo和replicate，提供数据存储量和代理流量的尺度。

- 连续内存，是agents和开发者团队的一种新方法，可以同步会话，并提示进入Git寄存器，使该数据可以不断获取和搜索以编码agents.

此外，我们正在建立一个开放的生态系统，这样开发者可以选择最好的工具来做这项工作。 一开始，我们与Buildkite和Depot合作持续整合(CI)，因此你的建造和测试管道跟上速度agents船。

今天任何开发者都可以获得全集，尤其对AI本土团队及其agents进行优化。 让我们跳进新的多段。

有轨电车审查

在拉动请求(PR)中，开发者以线性时间表发布其评论，连续集成(CI)提供底层状态，然后是合并按钮。 现在的编码和代码审查正在用长长的描述将这个时间线闪烁出来。 开发者要求他们的编码agent处理代码审查agents的反馈，然后进行另一次审查。 牵引请求已成为只有agent读取的审计日志。 它不提供开发者决定它们是否能够与信心合并的信息。

轨迹改变了这一点。 它带来页面顶端的相关信息作为 eval 分数，在每个推力上计算。 目标很简单：提供所有你需要的信息，以确定你的编码agent与审查agents之间的足够环路是否碰巧实现了稳定状态。 或者不是，需要再重复一次。 只有在信心高，风险低，所有发现都清除后，合并才会发生。

以下是轨迹在三步内如何运作：

1. 踏上困境

一个Trail可以通过提交错误报告或特性请求从全程开始。 或者你可以从你的 agent 直接启动一个拖车，执行开始之前或之后，就像你准备按下代码时会打开 PR 一样。 一个轨迹可以跨越多个寄存器，所以属于一起的改变被组合在一起。

2. 以Evals为轨迹

当代码被推到拖拉机时，全触发审查agents来审查承诺。 想想看，像陪审团判断冰滑冰表演。 每个agent在一个云沙盒中独立运行，并提交分数和理由。 例如，在全罗尔的很多仓库中，我们使用安全，Slop，和人类评论必需的eval。 如果斯洛普分数是橙色的，你可以指示你的agent继续根据这些数据进行校正和推力，直到分数变为绿色。 每个 eval 显示最后5 个运行和当前运行。 我们认为，这一点至关重要，因为一弹即发往往缺少一个关键问题。 重复循环和稳定分数对于代理编码的成功至关重要。

Entire上的每个项目都带有预定义的agents，用于代码质量，安全性，和slop，可以在每repo基础上启用。 您可以通过全用户界面配置自己的 agents，或者在 repo 中作为.json 配置。 在引擎盖下，Entire使用Claude Code和Codex与最新的模型，运行在代托纳和E2B提供的孤立云沙盒上。

3. 关闭所有发现，然后合并

在每次推力上，agents还可以返回具体的调查结果和建议的修饰，其严重程度不同。 公开的发现总是可见于"轨迹"，而解开的发现则被隐藏，但可以通过菜单检索。 这样，你总是保持警戒哪些仍然开放。 一个发现可以被agents或人类开发者处理或驳回，你猜到了。 也可以发布发现和评论，就像拉请求一样。

为了保证合并不会发生，其中包括人类认可和通过CI检查。

带有 Buildkite 和 Depot 的 CI

持续整合最早由Grady Bouch在1991年提出。 它对于现代软件开发生命周期的成功至关重要，使团队能够每天部署数百次。 agents写下所有代码，将CI作为保障更为重要，因此，我们激动地提供一流的CI供应商融入拖车，从今天的Buildkite和Depot开始。

构建kite

在整个项目中，CI是在项目一级配置的，因为项目中的多个储存库往往使用同样的基础设施。 一旦Buildkite连接起来，每个推力都建立在Buildkite或你自己的基础设施上。 就像在公关上，结果显示作为对你的轨迹的检查，一个失败的建筑会阻碍合并。 当然，agents可以通过Buildkite的API,CLI，或MCP，自行实现整个循环自动化。

如果您是 GitHub 动作用户，您可以通过运行 bk 管道转换来迁移工作流程，而无需重写。

投币

Depot为开发者提供快速，可靠的软件发送基础设施，并编码了agents，兼容GitHub Actions. Depot CI运行在中间没有GitHub的现有工作流程。

Teams可以在几下点击中连接来自Entire的Depot，并在同一流中创建Depot账户。 然后库 ci 迁移发现您的 GitHub 动作工作流程，将它们推广到 Depot CI 工作流程，并标出任何需要审查的工作流程。 Companion命令支持导入机密和变量，因此迁移的工作流程在几分钟内运行。 团队保持他们所建立的工作流程，并获得快速可靠的CI

您所在地区的主机重置

在发行版本控制进入主流之前，寄存器及其历史都生活在Subversion等系统上。 吉特改变了这一点。 开发者可以在当地创建承诺和分支，合并甚至重写历史，并在需要时稍后调和。 吉特协议支持分配甚至权力下放，但伪造从未实现。 Git向客户端分发寄存器，各种伪造将服务器的侧面集中，一次又一次。 我们认为这种集中的模式不适合未来，因为它缺乏可扩展性，韧性，以及控制我们代码存放的地方。

从今天开始，您可以创建并本土托管一个位于Entire上的寄存器，或者镜像一个来自GitHub. 整个由一个新的源控服务器提供动力，并用分布式对象存储器和仍然兼容Git的交易参考数据库进行缩放。 由于这种建筑，"全形"是目前生产速度最快的基特铸造。 根据我们的开源基准测试，推力比GitHub快达89x，比Cursor起源快6x. 用户和兽群可以在多个区域开展replicate项目和储存库，或将其保存在他们所居住的区域，例如数据居住要求。 我们今天在美国、欧盟、澳大利亚和印度直播。

创建新仓库

要启动，您可以从我们的网络界面或在使用全CLI的您的 agent 上创建一个关于全库的新库。 仓库设在属于某个组织或个人账户的项目内。 当您创建一个项目时，您会选择一个主区域，然后在一个或多个区域中选择 replicate。

镜像您的存储器( 保留 GitHub 作为真实的来源)

如果你希望GitHub继续成为真相的来源，通过授权 GitHub App for Entire 来镜像您的寄存器，然后选择全域的 repo 和区域。 你甚至可以使用拖车在拖拉请求之上，就像你会在全天线上使用一个本地寄存器。 镜像时，将交通线路推回GitHub. 如果服务中断，Entire会继续服务克隆人并从你的区域镜像中获取，而你的agents可以继续推向Entire-native分支(任何分支前缀全/unmirrored/)，直到GitHub回来。

移动您的仓库

如果您想从 GitHub 中迁移您的仓库，您有两种选择。 在美国镜像时，您可以通过打开寄存器的设置来拆卸自己的镜像，然后点击GitHub的Detach，并选择将其移入的项目。 或者，如果你想从GitHub直接迁移而不用镜像的话，你可以使用全模插件来照顾这个过程。 当然，你总是可以从GitHub得到，推到整个，在你的本地机器上，或者作为你CI/CD工作流程的一部分。

将会话转换为连续内存

每天，开发者和agents会做决定，发现限制，尝试新的方法，在构建特性和粉碎错误的同时学习什么是有效的。 但大多数知识在会话结束后消失。 当您开始新的会话时，您的 agent 打开一个新的上下文窗口，必须重新学习所有不仅缓慢而且昂贵的东西。

今天，我们正在引入一种新的概念，我们称之为持续记忆。 这样想想吧 CI 带来代码一起。 CD飞船持续记忆带去理解存储器是您 agent 需要的唯一内存。

在全CLI中有两个新的命令使得连续内存成为可能：全图，它映射了您的代码如何组合在一起，并在我们的测试中保存了高达71%的标语，全脑，它索引了您的agent会话，并把它们附在图表上，以创建持久的记忆，agent可以通过代码库比Greping更快地检索。 两个插件都是开源和本地的第一，它们的设计是为了一起工作：全脑建立在您代码的全图上。

您的代码库地图

全图将您的 agent 预算的您的 Git 仓库地图：排序代码搜索加定义，调用者，类型，路线，以及更改影响，都带有文件：线性位置。 内置分析器在本地对寄存器进行树保姆解析，不进行网络请求，模型调用，也不进行API-key的查询。

全脑

全脑为您的寄存器创建一个持久的内存层。 这让agents在正确的时间总是有正确的背景，在引擎盖下，全脑索引了您代码的全图，并将其与您通过全CLI记录的过去agent会话结合。

例如，如果您正在修复一个导致您计费系统中出现错配的错误的四舍五入错误，则全图会通过每个呼叫器和测试跟踪发票的计算结果，而全脑则会给您 agent 提供当前逻辑背后的意向，已经发运的修改以及原因，或者什么测试在上次有人更改时中断。

整个大脑也可以连接到整个后端，使您的团队的agent记忆能够生活在一个共享空间而不是单个机器中。 每一次拖车，然后是显示，agent所创造的记忆，因此审查员们可以看到开发商做出的决定以及agent学到的事实。 要开始，设置全图和全脑在你的仓库。

加入叛乱

在开始一年后，我们对已经变成什么以及我们的agents下一步的工作，但建设新的开发商平台只能与社区合作完成。 所以我们想听到你的消息，学习你

本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。

The Git Forge for Agent-Human Collaboration

After more than a year of hammering the iron, we’re excited to introduce the first Git forge built specifically for agent-human collaboration. Entire is built on three primitives:

- The Trail. Unlike the classic pull request model of reviewing code changes with a diff, Trails offers developers a heads-up display similar to an airline pilot, with automated customizable evals that are scored by agents on every code push.

- Distributed Git hosting. Entire is built on a new source control server compatible with Git, which pushes up to 89x faster than GitHub and 6x faster than Cursor Origin. You can host your repo and replicate it in multiple regions around the world, offering data residency and scale for agentic traffic.

- Continuous Memory, a new approach for agents and developer teams that sync sessions and prompts into the Git repository, and makes that data constantly available and searchable to coding agents.

Plus, we are building an open ecosystem, so developers can pick the best tools for the job. At the start, we are partnering with Buildkite and Depot for Continuous Integration (CI), so your build and test pipelines keep up with how fast agents ship.

Entire is available for any developer today, and especially optimized for AI-native teams and their agents. Let’s jump into the new multiverse.

Review with Trails

In a pull request (PR), developers post their comments in a linear timeline, and continuous integration (CI) provides a status at the bottom followed by the merge button. Now coding and code review are spamming this timeline with long descriptions. Developers request their coding agent to address the code review agents’ feedback and then do another review. The pull request has become an audit log that only the agent reads. It does not provide the information for the developer to decide whether they can merge with confidence.

The Trail changes this. It brings the relevant information to the top of the page as eval scores, which are calculated on every push. The goal is simple: Give all the information you need to decide whether enough loops between your coding agent and the review agents have happened to achieve a stable state. Or not, and another iteration is needed. Only when the confidence is high, risk is low, and all findings are cleared, the merge should happen.

Here’s how the Trail lifecycle works in 3 steps:

1. Spinning Up a Trail

A Trail can begin on Entire by filing a bug report or a feature request. Or you can start a Trail straight from your agent, before or after the implementation has started, like you would open a PR when you are ready to push code. A Trail can span multiple repositories, so changes that belong together are grouped together.

2. Scoring the Trail with Evals

When code is pushed to a Trail, Entire triggers review agents to review the commit. Think about it like a jury judging an ice skating performance. Each agent runs independently in a cloud sandbox and submits a score and a rationale. For example, across many of our repositories at Entire, we use Security, Slop, and Human Review Required evals. If the Slop score is orange, you can instruct your agent to continue correcting and pushing based on that data until the score turns green. The last 5 runs and the current run are shown for each eval. We believe this is crucial as one-shot loops are often missing a critical issue. Repeating the loops and stabilizing the scores is crucial for the success of agentic coding.

Each project on Entire comes with pre-defined agents for code quality, security, and slop that can be enabled on a per-repo basis. You can configure your own agents via the Entire user interface or as .json config in the repo. Under the hood, Entire utilizes Claude Code and Codex with the latest models, running on isolated cloud sandboxes provided by Daytona and E2B.

3. Close All Findings, Then Merge

On every push, agents can also return specific findings and suggested fixes with different severity levels. Open findings are always visible in the Trail, while resolved findings are hidden, but can be retrieved via the menu. This way, you always stay alert on what is still open. A finding can be addressed or dismissed, you guessed it, by agents or human developers. You can also post findings and comments, just like in a pull request.

To make sure the merge doesn’t happen without addressing the agent findings, Gates can be enabled per repo to define what is required before approval. These also include human approvals and passing CI checks.

CI with Buildkite and Depot

Continuous Integration was first proposed by Grady Booch all the way back in 1991. It has been crucial to the success of the modern software development lifecycle, enabling teams to deploy hundreds of times per day. Now that agents write all the code, it’s even more important to have CI as a safeguard, so the agent isn’t changing what the prompt didn’t intend. As such, we are excited to offer first-class integrations of leading CI providers into Trails, starting with Buildkite and Depot today.

Buildkite

On Entire, CI is configured at the project level as often multiple repositories within a project use the same infrastructure. Once Buildkite is connected, every push builds on either Buildkite’s or your own infrastructure. Like it would on a PR, the result shows up as a check on your Trail, and a failing build will block merging. Of course, agents can automate the entire loop on their own, via Buildkite’s API, CLI, or MCP.

If you are a GitHub Actions user, you can migrate your workflow by running bk pipeline convert without rewriting.

Depot

Depot provides fast, reliable software delivery infrastructure for developers and coding agents, compatible with GitHub Actions. Depot CI runs existing workflows without GitHub in the middle.

Teams can connect Depot from Entire in a few clicks and create a Depot account in the same flow. Then depot ci migrate discovers your GitHub Actions workflows, promotes them to Depot CI workflows, and flags anything that needs review. Companion commands support importing secrets and variables, so migrated workflows run within minutes. Teams keep the workflows they’ve built and get fast and reliable CI from the first run, billed by the second, so faster jobs cost less.

Host Repos in Your Region

Before distributed version control went mainstream, the repository and its history lived on systems like Subversion. Git changed that. Developers could create commits and branches, merge, or even rewrite history, all locally, and reconcile later when needed. The Git protocol supported distribution and even decentralization, but forges never lived up to it. Git distributed the repository to the client, and various forges centralized the server side, again and again. We believe this centralized model is not fit for the future as it lacks scalability, resilience, and control where to store our code.

Starting today, you can create and natively host a repository on Entire, or mirror one from GitHub. Entire is powered by a new source control server, scaled with a distributed object store and a transactional ref database that remains compatible with Git. Due to this architecture, Entire is the fastest Git forge in production today. According to our open-source benchmarks, pushes are up to 89x faster than GitHub and 6x faster than Cursor Origin. Users and orgs can replicate their projects and repositories across multiple regions, or keep it in the region they reside in, for example for data residency requirements. We are live today in the US, EU, Australia, and India.

Create a New Repository

To get started, you can create a new repository on Entire from our web interface or from your agent using the Entire CLI. Repositories live inside projects belonging to an organization or a personal account. When you create a project, you pick a primary region and then replicate your repository across one or more regions.

Mirror Your Repository (Keep GitHub as Source of Truth)

If you’d like GitHub to remain the source of truth, no problem. Mirror your repository by authorizing the GitHub App for Entire, then picking the repo and the regions on Entire. You can even use Trails on top of pull requests, just as you would with a repository natively hosted on Entire. When mirroring, push traffic routes back through GitHub. If there is a disruption in service, Entire will keep serving clones and fetches from your regional mirror, and your agents can keep pushing to Entire-native branches (any branch prefixed entire/unmirrored/) until GitHub is back.

Migrate Your Repository

If you’d like to migrate your repository from GitHub, there are two options available to you. When mirroring in the United States, you can detach your mirror by opening the repository’s settings, then clicking Detach from GitHub, and choosing the project to move it into. Or, if you’d like to migrate directly from GitHub without mirroring, you can use the entire-migrate plug-in which takes care of the process. And, of course, you can always just fetch from GitHub and push to Entire, on your local machine or as part of your CI/CD workflow.

Turn Sessions Into Continuous Memory

Every day, developers and agents make decisions, discover constraints, try new approaches, and learn what works while building features and squashing bugs. But most of that knowledge disappears when the session ends. When you start a new session, your agent opens a new context window and has to re-learn everything which is not only slow but also expensive.

Today, we are introducing a new concept that we are calling Continuous Memory. Think about it this way: CI brings code together. CD ships it. Continuous Memory carries the understanding forward. The repository is the only memory your agent should need.

Two new commands in the Entire CLI make Continuous Memory possible: entire-graph, which maps how your code fits together and in our testing saved up to 71% on tokens, and entire-brain, which indexes your agent sessions and attaches them to the graph to create durable memories that the agent can retrieve faster than grepping through the codebase. Both plugins are open source and local first, and they’re designed to work together: entire-brain builds on entire-graph’s map of your code.

A Map of Your Codebase

entire-graph hands your agent a precomputed map of your Git repository: ranked code search plus definitions, callers, types, routes, and change impact, each with file:line locations. The built-in analyzer parses the repository locally with tree-sitter and makes no network requests, model calls, or API-key lookups.

entire-brain

entire-brain creates a durable memory layer for your repository. This allows agents to always have the right context at the right time, aka the “why” behind the “what changed.” Under the hood, entire-brain indexes entire-graph’s map of your code and binds it with past agent sessions that are recorded in your Git history via the Entire CLI.

For example, if you were fixing a rounding bug that created a mismatch error in your billing system, entire-graph traces the invoice calculation through every caller and test, while entire-brain gives your agent the intent behind the current logic, the fixes already shipped and why, or what tests broke the last time someone changed it.

entire-brain can also be connected to the Entire backend, enabling your team’s agent memories to live in one shared space instead of individual machines. Every Trail then shows the memories that the agent created, so reviewers see what decisions the developer made and what facts the agent learned. To get started, set up entire-graph and entire-brain in your repository.

Join the Rebellion

A year after we started, we couldn’t be more excited about what Entire has already become and what our agents are working on next. But building a new developer platform can only be done in collaboration with the community. So we want to hear from you, learn from you, and

Auto-fetched and translated by AI Atlas. All rights belong to the original author.