Agent-人类合作的基特堡

Agent-人类合作的基特堡

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

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

- 分布式吉特托管。 整个由与Git相容的新源控制服务器所建，其推速可达89x快于GitHub,6x快于Cursor Origin. 您可以在全球多个地区托管您的 repo 和 replicate，为代理流量提供数据存储和比例。

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

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

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

与拖车一起审查

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

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

以下是轨迹生命周期在3个步骤中的运作方式：

1. 铺起一股绊倒

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

2. 以Evals为轨迹

当代码被推向有轨电车时，全能触发审查agents来审查承诺。 想想看，像陪审团判断冰花滑冰表演。 每个agent在一个云沙盒中独立运行并提交分数和理由。 例如，在全天下我们的许多储存库中，我们使用安全、斯洛普和人类评论所需的电子报告。 如果斯洛普分数是橙色的，你可以指示你的agent继续根据这些数据进行校正并推取，直到分数变为绿色。 每个 eval 显示最后 5 运行和当前运行。 我们认为，这一点至关重要，因为一发环往往缺少一个关键问题。 重复循环并稳定分数对代理编码的成功至关重要。

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

3. 关闭所有结果，然后合并

在每次推力上，agents也可以返回具体的调查结果并给出不同严重程度的修补建议。 公开的发现总是在"有轨电车"中可见，而解开的发现则被隐藏，但可以通过菜单取出。 这样，你总是保持警觉在什么仍然开放。 一个发现可以被agents或人类开发者处理或驳回，你猜到了。 也可以发布发现和评论，就像拉出请求一样。

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

带有 Buildkite 和 Depot 的 CI

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

建树

就整个而言，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 工作流程，并标出任何需要审查的工作流程。 company命令支持导入机密和变量，因此迁移的工作流程在几分钟内运行。 团队保持他们建立的工作流程，并获得快速可靠的CI

您所在地区的主机重置

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

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

创建新仓库

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

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

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

移动您的仓库

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

将会话转换为连续内存

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

今天，我们正在引入一种新的概念，我们称之为持续记忆。 考虑一下：CI 带来代码一起。 CD载运。 持续的记忆带理解向前。 该寄存器是您 agent 唯一需要的内存。

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

您的代码库地图

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

全脑

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

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

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

加入叛乱

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

本文由 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 Gem Box. All rights belong to the original author.