7 People, 5 Months: Anthropic Built a Git Replacement

marsbitPublished on 2026-10-14Last updated on 2026-10-14

Abstract

In a surprising move, Anthropic replaced Git, the dominant version control system for two decades, with its own internally developed system named Scion. This migration was accomplished in just five months by a team of seven engineers, heavily assisted by their AI model, Claude. The primary driver was the explosive growth of AI-powered software development at Anthropic. By September, the company was handling over 30,000 code merges per day—a 12x increase in just four months—straining Git's decentralized, offline-friendly architecture which was not designed for such massive, centralized, and always-online agent-driven workflows. Scion was designed from the ground up for this new paradigm. Its core principles include: assuming clients (AI agents and automation) are always online; offloading complex computations (like blame, diff, merges) to scalable servers; providing a full API for source control queries to eliminate local repo needs for many tasks; and enabling highly efficient, sparse, and virtualized checkouts. Key to Scion's performance is its data structure. Instead of Git's commit-and-tree model, it uses a "Changeset" stored in a write-ahead log, which records only changed files. This allows for extremely high-throughput ingestion. Additional "derived data" structures are built on-demand for operations like blame and history queries. The new architecture employs a distributed, cache-heavy design with daemons (scion-daemon), regional caches (scion-cache), and authorita...

Git, the version control tool that has dominated programming for 20 years, has been replaced by a new system built in-house by Anthropic.

And it was accomplished by just 7 engineers and the deeply involved Claude.

In 5 months, Anthropic developed from scratch an internal source code control system called Scion, a supporting code review tool Antique, and several other related systems, and completed the migration of the entire monolithic code repository from Git to Scion.

What does this mean? A few people, with the help of AI, took only a few months to create a new system and directly replace Git, which had been used internally for many years. It's simply astonishing! This naturally led some to exclaim 'RIP GIT'.

Why build a Git replacement themselves?

The reason is simple: Anthropic's AI programming scale has grown so large that the existing development infrastructure is struggling to cope.

Data provided by Anthropic shows that in May of this year, they merged about 2,500 code changes per day on average. By September, this number had exceeded 30,000, a more than 12-fold increase in just 4 months. Furthermore, Anthropic expects this growth will not slow down in the short term. The potential demand for code merging is almost unlimited; whenever a bottleneck is solved, code output increases further.

Forced by this reality, Anthropic developed its internal version control system and, within five months, fully migrated the entire Monorepo from Git to Scion.

Anthropic detailed the entire process in a recent blog post.

I. The Continuously Expanding Monorepo

Before introducing Scion, it's necessary to explain how unique Anthropic's workload is. The extent to which they use Claude to write software far surpasses that of most companies. This reveals where tools designed for human-scale development start to struggle. Source control is just one example.

Anthropic expects not many companies will encounter similar problems in the short term. But as AI programming tools become more widespread, other companies likely won't be far behind in hitting similar bottlenecks. This is also why they decided to share their experience in designing and developing Scion.

Git is a decentralized system. Each clone produces a complete, independent code repository. Even fully offline, developers can compute diffs, view commit history, track modification records for a specific line of code, and check out any version. For the vast majority of repositories, this design is very reasonable and a key reason Git became the industry standard.

But as Anthropic's Monorepo continued to grow, Git's design became increasingly inadequate. Currently, the historical data for just the main branch is nearly 100GB, and the compressed working copy exceeds 25GB. The CI system alone performs about 25 million code checkouts per day, not counting development environments, Agent sandboxes, and research tasks. If every instance fetched the required data directly from Git, the daily data transfer volume would exceed 600PB.

Git does offer features for handling partial repository data, such as shallow clones, sparse checkouts, and promisor remotes. The industry also has common methods for dealing with large Monorepos, like setting up internal Git mirrors or storing repository snapshots in object storage.

Anthropic tried all these methods. At peak load, they even ran hundreds of internal Git mirror servers. These solutions indeed helped them hold on for a while. But as code merge volume kept growing, maintaining them became increasingly difficult. Between snapshot refreshes, the gap between a snapshot and the latest version of the main branch grows. Also, getting operations like diff and blame, which rely on historical information, to work correctly on partially cloned repositories required more and more maintenance effort.

Typical architecture for extending Git checkout capabilities.

Later, Anthropic re-evaluated their usage pattern and identified an issue. Like most companies, Anthropic was essentially using Git as a centralized system, with all development revolving around a single authoritative code repository. But the clients are almost all Agents and automated tasks, which are inherently always online. The features Git provides for distributed and offline development actually limit the system's scalability as the repository grows.

So, Anthropic began to think: if we designed a source control system from the ground up for the characteristic that Agents are always online, what should it look like?

II. Source Control for Agent Scale

As Agents begin to write code in large quantities, many traditional assumptions in software development are changing. When designing Scion, Anthropic fully considered these changes, leading them to adopt different approaches from Git on several core principles. Of course, source control for extremely large Monorepos is not without precedent. Google's Piper and Meta's Sapling have accumulated rich experience, which Anthropic referenced during Scion's development.

Scion primarily follows these design principles.

1. Clients are always online.

Git assumes clients need to work offline, so they must keep a complete repository locally. But Anthropic's clients are almost all Agents and automated tasks, so they designed Scion's clients and communication protocol around an always-accessible server. Clients fetch only the data they need from the server.

2. Clients and servers have different responsibilities.

In Git, each client is capable of acting as a full Git server. Scion delegates most of the work to the server, including querying file history and blame information, creating commits, performing merges and rebases, etc. Clients are only responsible for maintaining a size-limited local object cache, writing files from the working copy to disk, monitoring file system changes, and providing user-friendly interfaces. The clients themselves perform almost no complex computation, so they keep much less data locally.

3. A complete source control service can support many new applications.

In Git, if a CI task or other tool wants to query repository information—like who last modified a line of code or the relationship between two commits—it typically needs to maintain its own local repository. Another approach is to rely on APIs provided by specific vendors, but these APIs might not answer all questions. Scion exposes all source code query functions used by clients as APIs. This way, many tasks don't need a local repository at all to perform queries.

Anthropic's internal automated bisection and code rollback pipelines are examples. Without this low-cost, programmatically accessible source code access, these tools would be difficult to operate at the current scale.

4. All components must support horizontal scaling.

In the past, Anthropic ran up to hundreds of Git mirror servers, consuming a significant amount of computing resources. Moreover, once the repository size exceeded the disk or memory capacity of a single mirror server, further scaling became very difficult.

Scion stores repository data in a distributed manner, with each component scalable independently. The entire system has no single complete, materialized code repository—not even on the servers. Scion also lacks a mechanism equivalent to Git's packfile (compressed object pack), so it doesn't require related repository maintenance operations.

5. Commits must be lightweight, support incremental processing, and not require locking.

In Git, developers commit code locally first, then share changes via push. All commit, rebase, and merge operations in Scion are performed on the server side, so there is no push. However, this means the server must be able to process these operations quickly. The cost of creating a commit and updating related data structures must be proportional to the size of the change, not to the overall size of the repository. Otherwise, the server will eventually fall behind the commit rate.

Scion's development workflow also minimizes the use of refs. Refs are pointers to commits, such as branches and tags, and Scion typically retains only necessary refs like the main branch or release branches. Because global data that all servers need to maintain consistently will likely become a scaling bottleneck in the future.

6. Working copies can be optional; checkouts default to fetching only needed data.

Anthropic's Monorepo is enormous, and CI performs tens of millions of checkouts daily, so they wanted to avoid unnecessary checkout operations as much as possible. For example, if a CI task needs to compute the diff between a commit and its merge base, it can query the Scion server directly. Many write tasks can also skip code checkout entirely, being performed via APIs.

Scion's protocol is designed primarily around sparse and virtualized checkouts. Sparse checkouts only include directories explicitly needed by the client. Virtualized checkouts load files only when they are actually needed. This way, even if a task must use files on disk, it only fetches what it actually reads.

III. How Scion Works

With these design principles in mind, let's see how Scion implements them. These experiences could be applied to other source control systems and may also be helpful for other parts of the software development process.

Data Structures

In Scion, the basic unit of work is called a Changeset, which is a record in a Write-Ahead Log (WAL).

A Changeset holds most of the common information found in a Git Commit, but the data is organized differently. A Git Commit holds a pointer to a directory tree, while a Changeset holds a list of files changed relative to the first parent commit, along with content-addressed pointers to the compressed file contents in object storage. Changesets are created on the server and are immediately accessible from anywhere in the system.

The data structure of a Changeset in Scion.

This structure allows Scion to receive changes with extremely high throughput. Because it doesn't need to receive packfiles, doesn't require locking or cross-server coordination, and doesn't need to move refs. Strictly speaking, Scion still supports refs. But creating and fetching commits doesn't depend on refs, so moving a ref requires only a single Compare-and-Swap operation on one row in Spanner, and this operation is separate from creating the Changeset.

However, a Changeset only records what changed. These records alone can't quickly answer questions like who last modified a line of code or which commits affected a file path. To solve these problems, Scion builds additional data structures based on Changesets, including specialized structures for querying blame and file path history, and skip lists for accelerating commit graph queries.

Anthropic collectively refers to data not directly part of a Changeset as Derived Data. All derived data is computed through a generic mechanism. Each type of derived data is defined recursively: the derived data for a Changeset can be computed from the corresponding data of its parent Changeset(s).

This mechanism has three benefits.

First, if they find an operation could be accelerated by a new data structure, they can easily add a new type of derived data.

Second, each type of derived data can independently decide whether to compute it eagerly or lazily, avoiding generating unused data.

Third, clients don't need to understand the internal implementation of these data structures, so they can continuously optimize server-side data structures without modifying clients.

As Scion evolved, Anthropic has added several new derived data types multiple times, such as new indices for detecting file copies and searching files by path.

Scaling Scion

A relatively small cluster of Scion servers provides various source control APIs to clients, including fetching Changesets, computing diffs, finding merge bases, and fetching Blobs. All source code data is content-addressed, so once written, the content never changes. Any server can cache this data without coordinating with others.

Therefore, Scion servers can scale horizontally, requiring minimal coordination among themselves. These servers essentially act as large caches, while also computing derived data on demand and writing results back to Spanner.

Numerous internal tools using Scion no longer need to maintain their own local repositories. In the past, if CI tasks or other tools needed to query commit ancestry or track code changes, they had to first acquire and maintain a code repository, which was a significant maintenance burden. In fact, early in the migration, before they had their own client, repository format, and communication protocol, Scion could only answer these metadata queries. In contrast, fetching file contents and generating working copies on disk involved much larger data transfers, so they designed a separate solution for those capabilities.

Scion's scn client differs from Git in several important ways in its data fetching protocol, enabling an architecture that is more scalable and has significantly lower CPU overhead than Git servers. During data fetch negotiation, Scion doesn't have the client first tell the server what data it already has. Instead, the client directly requests the directory trees and Blob objects it wants. The client starts from the root directory tree, checks which tree objects are missing locally, and recursively requests them from the server. After fetching trees, it fetches Blobs in the same way. Each request points to a specific, immutable object, so any cache can return the result.

The entire architecture is very similar to a traditional hierarchical caching system. This method is highly efficient, supports resumption from interruptions (because the process doesn't rely on a single packfile response that could be several GB), and doesn't require special support for sparse or virtualized checkouts. The client simply doesn't request directory trees it doesn't need.

In Anthropic's compute clusters, clients communicate via socket with a daemon process called scion-daemon. The scion-daemon stores code objects for the entire compute node. Since most nodes need access to the Monorepo, different tasks on the same node often reuse a large amount of identical data, making it more efficient for the daemon to manage caching centrally. Each scion-daemon loads a periodically updated snapshot upon startup. It then communicates only with tree and Blob cache servers in its Region, called scion-cache.

scion-cache serves objects directly from memory in the same format that the daemon ultimately writes to disk. Therefore, cache servers don't need to compute which objects the client lacks or perform delta compression. When a cache server lacks an object, scion-cache requests it from the authoritative scion-server. scion-server then reads the data from Spanner or cloud storage as needed.

scion-daemon, scion-cache, and scion-server all use the same RPC interface, so clients don't need to know the topology of the caching system. Theoretically, any layer could communicate with any other. But Anthropic strictly defines access relationships between layers to isolate failures. For example, if scion-cache in a Region fails, Anthropic doesn't want a flood of requests to go directly upstream to scion-server, potentially taking down the entire system.

Scion's code checkout architecture.

Every layer of this system achieves a cache hit rate of over 99%, and none require maintaining long-term state, making it easy to scale on demand. Compared to the previous Git mirror infrastructure, Scion's resource consumption for CPU and memory has been reduced by a factor of 200. CI and research task checkout speeds have improved by about two orders of magnitude, from minutes to seconds. This has freed up massive resources across the compute cluster, saving 25% of CPU capacity for the CI system alone. Additionally, neither clients nor cache servers need to perform repository maintenance tasks, simplifying task lifecycle management.

IV. What Was Learned from Developing Scion?

The time Anthropic began developing Scion coincided with the internal availability of Claude Mythos Preview and Claude Tag. These models, on one hand, further increased the need for Scion, and on the other, significantly accelerated its development.

Here's a representative example. Earlier this year, Anthropic largely hand-wrote the first prototype of the Git-to-Scion data import pipeline. At the time, they thought it was quite good. Later, when they got an early internal version of Claude Mythos Preview, they had Claude rewrite the entire program without any additional instructions. The result was an implementation that used 20 times less memory and ran 4 times faster, while fully preserving all the implicit constraints about import order and data structures in the original program.

Weekly number of code changes merged into the Scion and Antique codebases from January to September 2026.

The experience of developing and running Scion gave Anthropic some new insights into agent-scale software development.

Small Teams Rapidly Developing Large Systems Will Become Increasingly Common

A team of just 7 people developed Scion and the code review tool Antique in 5 months, also built about half a dozen related systems, and completed a full migration to them. Antique alone warrants a full engineering blog post.

And this entire development and migration happened during a period when Anthropic's daily code merge count grew tenfold. In the past, developing and deploying such a source control system typically required many more engineers and years of iteration and gradual migration.

Anthropic believes this kind of rapid, flexible system development and migration will become increasingly common in the future.

Engineers Are Still Important, But Their Working Style Is Changing

All engineers involved in this project now consider Claude's code-writing ability to surpass their own. But engineers still play an irreplaceable role. Team members understand the overall relationships between systems and the trade-offs required by different architectural designs. Anthropic knew the problem they were solving and the scale the system needed to support, allowing them to make sound design decisions. Often, they found the engineer's job was to say 'no' to Claude.

Agents sometimes violate core constraints the system must obey in order to satisfy a certain code pattern. This was especially common during migration. For example, several systems needed to query when a particular code change was merged into the main branch. Claude attempted to find the answer by linearly scanning the commit log, when in reality it could have directly queried their code review tool.

Anthropic also heavily employs adversarial code review. This is very effective in many ways, but sometimes it can overly focus on local issues. Therefore, experienced engineers need to guide Claude promptly to prevent it from overcomplicating the design due to hypothetical risks. For instance, one review was overly cautious about trusting another internal service, causing Claude to add numerous extra validations, making the system more complex. Currently, team members still review every code change request for this system. However, they now mainly check if the intent of the change is reasonable, rather than reading every line of code.

Significantly Improved System Performance and Code Quality

Claude can write large amounts of code much faster than human engineers, making Scion one of the most thoroughly tested and well-protected codebases Anthropic has ever encountered. Even under tight development timelines, they still built fully isolated, reproducible simulation tests covering various complex infrastructure interactions and source control operations they had previously encountered.

Additionally, they incorporated fuzz testing and comprehensive rate-limiting mechanisms. Claude also frequently and easily discovered important performance optimization opportunities. For example, it once found that a commit ancestry query algorithm was missing an existing index, leaving room for optimization. An expert might have needed days or weeks to analyze and tune such a problem, but Claude completed the optimization and could do something similar the next day.

Actual performance improvement for Scion's native repository.

Laid a New Foundation for Monorepo Security Management

For massive Monorepos, security and compliance are just as important as capacity and scalability. Anthropic considered these issues from the very beginning of Scion's design. Scion supports rich repository access controls and can set permissions at the individual directory level. This protects the most sensitive code while retaining the benefits of a Monorepo.

Furthermore, the code review tool they developed supports complex, semantics-based approval constraints. For example, the system can distinguish between simple changes that only modify comments and modifications that involve sensitive program logic. This allows human reviewers to focus their attention on changes with greater impact.

System Operations Can Reach a New Level

Anthropic's team heavily uses Claude Tag to monitor various system components, for instance, by creating dedicated Slack channels where a Claude continuously watches the operational status of a particular component. They call these Clauses 'Superfans.'

Currently, Anthropic has a Superfan for scion-daemon, a Superfan for scion-cache, and a Superfan dedicated to watching Antique's merge queue. They have access to system telemetry and logs. These Clauses are like experienced engineers with ample time, constantly refreshing monitoring dashboards looking for anything unusual.

Of course, they still maintain traditional alerts for all systems. But in comparison, Superfans can detect very subtle, never-before-seen issues that make traditional alerts seem one-dimensional.

Rethinking Many Past Practices

This project prompted Anthropic to re-examine workflows designed for human-scale development. For example, in the context of large-scale Agent programming, traditional merge queues might no longer be appropriate. While one set of tests is running, hundreds or even thousands of code changes could be merged into the repository. In this scenario, how should CI even work?

So far, they haven't been able to effectively replicate the industry's common practice of managing merge queues with a global repository lock. Therefore, they've put more effort into post-merge automated testing and pre-deployment automated testing. Of course, this means concurrently ongoing changes can conflict. But Claude can often fix such conflicts before human engineers even notice them.

V. What Does This Mean for the Broader Developer Ecosystem?

Anthropic believes Scion is only one part of solving the scalability problems brought by increasingly capable AI Agents. Sharing these details aims to provide inspiration for other teams from their practices.

But they also don't believe Scion's approach is suitable for all scenarios. Scion is absolutely not a general-purpose replacement for Git. The design ideas discussed are mainly applicable to truly massive Monorepos, such as those used by tens of thousands of engineers or continuously generating code from numerous Agents.

Furthermore, Anthropic has a special condition: they can consume tokens for internal tasks on a scale far exceeding what other companies would realistically be willing to bear. This is done both to meet their own software development needs and to test Claude's capabilities. Practically speaking, turning Scion into a product widely usable by other companies would also be very difficult.

Scion differs significantly from Git. If another company wanted to migrate to Scion, they would need to migrate every aspect of their software development process and also require matching code review, code search, and CI systems. Anthropic's internal systems are highly customized, making them difficult for others to adopt directly.

Anthropic is also concerned that attempting to develop a public version satisfying everyone's needs might result in a product that isn't very useful. However, they expect such problems to become increasingly common within the next 6 to 12 months. It would be a massive waste of engineering resources if every company using Git had to solve similar problems on their own.

Therefore, Anthropic believes the most valuable approach currently is to share their design ideas, enabling other developers to apply some of Scion's effective solutions to Git without completely abandoning Git's existing overall model. For example, a Git server doesn't necessarily have to work the same way as a Git client. New server architectures already exist that can significantly improve system scalability.

Git hosting platforms could also provide a full set of server-side RPC interfaces, like Scion does. These interfaces could even be standardized across different code hosting platforms, allowing Git clients to call them directly. Git's current data negotiation protocol doesn't necessarily need to stay the same. Additionally, Git's existing sparse checkout and shallow clone features could be further improved to work better together.

References:

https://x.com/AnthropicAI/status/2110047081414987957

https://www.anthropic.com/engineering/redesigning-source-control

This article is from the WeChat public account "Machine Heart" (ID: almosthuman2014), author: Focus on Git.

Trending Cryptos

Related Questions

QWhat is the name of the internal source control system that Anthropic developed to replace Git, and how long did it take to build and migrate?

AThe system is called Scion. It took a team of 7 engineers, with significant assistance from Claude, 5 months to develop from scratch and migrate their entire monorepo from Git to Scion.

QAccording to the article, what was the primary reason Anthropic needed to develop a replacement for Git?

AThe primary reason was that their AI-driven programming had scaled to a point where their existing development infrastructure, Git, could no longer handle the load. Specifically, their daily code merges grew from 2,500 to over 30,000 in just four months, creating massive data transfer demands that Git's decentralized design couldn't efficiently support for their primarily online, agent-based workloads.

QWhat are two key design principles of Scion that differ fundamentally from Git's approach?

ATwo key principles are: 1) Scion is designed with the assumption that clients (mostly AI agents and automation) are always online, so it is architected around a central server. Clients fetch only the data they need on-demand, unlike Git which requires a full local repository. 2) Scion separates client and server responsibilities much more strictly, offloading complex computations like creating commits, merges, and history queries to the scalable servers, making the clients much simpler and lighter.

QWhat role did Claude, the AI model, play in the development of Scion, according to the article?

AClaude played a central role in accelerating development. It wrote large amounts of code rapidly, often producing more efficient implementations than the human engineers (e.g., rewriting a data import pipeline to be 4x faster and use 20x less memory). Engineers focused on high-level architecture, design trade-offs, and guiding Claude by saying 'no' when its solutions violated core system constraints or overcomplicated designs.

QDoes Anthropic believe Scion is a suitable general-purpose replacement for Git for most companies? Why or why not?

ANo, Anthropic does not believe Scion is a suitable general-purpose Git replacement. It is specifically designed for extremely large monorepos used by thousands of engineers or vast numbers of AI agents. Migrating to Scion would require overhauling an entire software development workflow (code review, CI, etc.). Anthropic suggests the most valuable approach is to share Scion's design insights so others can apply effective patterns to improve Git's scalability without abandoning it entirely.

Related Reads

Strategy stock sheds 5% amid MSCI index removal, Bitcoin sell-off

Strategy (Michael Saylor's Bitcoin treasury company) fell 6.49% on Thursday to close at $114.41, after MSCI confirmed the company's removal from its global equity indexes, compounded by a broader crypto market sell-off. The removal takes effect after the Nov. 30 market close and could trigger selling by index-tracking funds; JPMorgan previously estimated roughly $2.8 billion in potential selling pressure. Ryan Kirkley, CEO of Global Settlement Network, said the decision could distinguish Bitcoin treasury companies from traditional operating businesses and limit indirect crypto exposure for passive investors, noting that index inclusion had given ordinary passive investors leveraged Bitcoin exposure they never chose. He added it raises questions about whether such companies should be classified alongside traditional operating businesses, arguing that buying and holding an asset isn't an operating business but rather a fund that doesn't follow fund rules. In its Aug. 31 response to MSCI's proposed rules, Strategy called the changes a pretext for targeting digital asset treasury companies and downplayed the impact, saying MSCI-linked funds held about 13 million of its shares, just 3.1% of basic shares outstanding. The decline coincided with a broader crypto sell-off, with Bitcoin near $71,340, down 4.3% in 24 hours, and total crypto market capitalization down 3% to about $2.49 trillion.

cointelegraph1h ago

Strategy stock sheds 5% amid MSCI index removal, Bitcoin sell-off

cointelegraph1h ago

US Justice Department, business groups and DeFi firms challenge Illinois crypto tax

The US Department of Justice, business and financial industry groups, and a coalition of DeFi firms have backed a legal challenge to Illinois' 0.2% digital asset tax, arguing it unfairly targets crypto transactions and could impose taxes even without profit. The Justice Department filed a statement of interest, while the US Chamber of Commerce and SIFMA submitted an amicus filing. A coalition including Andreessen Horowitz, Paradigm, Uniswap and Aave Labs also filed a brief. The law, enacted in June, taxes the value of digital assets exchanged, transferred or stored regardless of profit. The Digital Chamber sued Illinois officials in July, followed by a separate challenge from the Blockchain Association and Crypto Council for Innovation in August. Originally set for Jan. 1, 2027, the tax was delayed to July 1, 2027. Illinois projected $60 million in fiscal year 2027 revenue. SIFMA and the Chamber warned the tax would affect banks, broker-dealers, custodians and asset managers nationwide, exposing them to compliance costs and burdening customers—someone who loses money owes the same tax as someone who profits, and moving assets between accounts could trigger tax without a sale or gain. They argued it discriminates against digital assets and may violate federal internet tax protections and constitutional interstate commerce requirements. The DOJ said the tax undermines federal efforts to promote crypto innovation, citing the Strategic Bitcoin Reserve and GENIUS Act. The DeFi coalition warned the rules could impose obligations on software developers and blockchain participants lacking customer information or control over funds.

cointelegraph1h ago

US Justice Department, business groups and DeFi firms challenge Illinois crypto tax

cointelegraph1h ago

DTCC Plans Solana Expansion as Wallet Rules Limit Access

DTCC plans to connect its tokenization service to Solana in the second half of 2027, allowing certain securities held by its DTC subsidiary to be converted into digital tokens on the network. Analysts say the move could attract more traditional financial institutions to Solana, which is known for fast transactions and low fees and had about $4.94 billion in total value locked as of Nov. 12. However, the impact may be limited by US regulatory rules. Alex Lin of Reforge noted that Solana's experience handling memecoin trading served as a public stress test, giving the network credibility to handle retail-scale volume reliably. Still, under a December 2025 SEC no-action letter, DTC participants must register wallets to hold tokenized securities, and tokens can only be transferred between registered wallets. Lin said the near-term impact is overstated because the tokens remain in a walled garden, inaccessible to permissionless retail and DeFi liquidity until regulators allow these assets to function as true onchain collateral. DTCC launched its tokenization service on the Canton Network and its private Besu network on Oct. 28, with 20 DTC participants signed on, though it has not said whether any plan to use Solana. Kha Nguyen of Birdeye said Solana has already seen growing demand for tokenized stocks, with trading volume reaching around $4.9 billion in H1 2026 and over 1 million accounts holding tokenized stocks by late September. However, broader Solana activity has slowed, with transactions down nearly 40%, DEX volume down 34.4%, and fees down 39%, while tokenized RWA value rose almost 7% to $4.76 billion. Nguyen said DTCC's integration would need banks, brokers, and issuers to actively issue, trade, and settle on Solana, with enough liquidity for large trades. He stressed that assets must be active rather than idle—traded around the clock, used as collateral, and earning yield. Lin agreed that long-term impact depends on where assets are used for secondary trading and collateral activity, not where they are issued.

cointelegraph2h ago

DTCC Plans Solana Expansion as Wallet Rules Limit Access

cointelegraph2h ago

Trading

Spot

Hot Articles

How to Buy PEOPLE

Welcome to HTX.com! We've made purchasing ConstitutionDAO (PEOPLE) simple and convenient. Follow our step-by-step guide to embark on your crypto journey.Step 1: Create Your HTX AccountUse your email or phone number to sign up for a free account on HTX. Experience a hassle-free registration journey and unlock all features.Get My AccountStep 2: Go to Buy Crypto and Choose Your Payment MethodCredit/Debit Card: Use your Visa or Mastercard to buy ConstitutionDAO (PEOPLE) instantly.Balance: Use funds from your HTX account balance to trade seamlessly.Third Parties: We've added popular payment methods such as Google Pay and Apple Pay to enhance convenience.P2P: Trade directly with other users on HTX.Over-the-Counter (OTC): We offer tailor-made services and competitive exchange rates for traders.Step 3: Store Your ConstitutionDAO (PEOPLE)After purchasing your ConstitutionDAO (PEOPLE), store it in your HTX account. Alternatively, you can send it elsewhere via blockchain transfer or use it to trade other cryptocurrencies.Step 4: Trade ConstitutionDAO (PEOPLE)Easily trade ConstitutionDAO (PEOPLE) on HTX's spot market. Simply access your account, select your trading pair, execute your trades, and monitor in real-time. We offer a user-friendly experience for both beginners and seasoned traders.

10.4k Total ViewsPublished 2024.03.29Updated 2026.06.02

How to Buy PEOPLE

Discussions

Welcome to the HTX Community. Here, you can stay informed about the latest platform developments and gain access to professional market insights. Users' opinions on the price of PEOPLE (PEOPLE) are presented below.

活动图片