How can we build decentralized markets on ArcBlock?

Building a decentralized market on ArcBlock need not begin by copying an exchange. The chain already has an exchange primitive. Combine it with persistent personal space, applications people can run and their own AI agents, and participants could publish intentions, find counterparties and agree on terms before settling on-chain.

In a recent discussion, I described a direction I find more interesting: a DEX or token vending machine delivered as a Blocklet that people can deploy, configure, own and operate. A Blocklet is a deployable application unit. It could be someone's private trading terminal, or software a developer distributes for others to run.

The question behind that idea is larger than whether we should build a swap page. We have moved settlement onto blockchains. How much of the market before settlement can we put into the hands of its participants?

ArcBlock's chain provides a native exchange transaction. DIDs provide verifiable identity. ARC supplies a computing environment for applications, resources and communication; ArcSpace can carry persistent personal state and a reachable endpoint in the architecture proposed here. Combining those foundations with a user's own AI agent creates room to explore another kind of market. This is an architectural direction, not an announcement of a complete market product available to install today.

A chain can exchange assets. Someone still has to organize the market.

Exchange was part of our chain from version 1.0, rather than a feature added recently to support a DEX narrative. The 2019 DApps Workshop already listed ExchangeTx among the transactions developers could try. The protocol later evolved into ExchangeV2. Treating exchange as a basic chain capability has been a deliberate choice throughout that history.

Suppose Alice wants to exchange asset A for B and Bob wants the reverse. They must find each other and agree on terms. They must also deliver together. A suitable atomic transaction on one chain can address the second problem: either both sides of the exchange execute, or the exchange does not take effect. That does not introduce Alice to Bob.

ArcBlock's ExchangeV2 protocol represents the two asset baskets directly. Tokens can be exchanged for assets, and supported combinations can be exchanged subject to the assets' rules. Common exchange semantics need not be implemented in a new settlement contract by every application. The primitive does not locate a buyer, determine a price or operate an order book.

Ethereum is already very good at trustless settlement. Solana programs can provide corresponding atomic state changes. Uniswap goes further than settlement: an AMM commits liquidity to a pool and uses pricing rules to serve demand without waiting for a simultaneous opposite order. 0x separates off-chain orders from on-chain execution; modern solvers compete over how to satisfy a user's constraints. These are achievements to build on. Uniswap whitepaper, 0x order specification.

Between wanting a trade and signing one lie publishing, discovery, inquiries, comparison and selection. Who selects the quotes I see? Who chooses the route? How long am I willing to wait, and what am I willing to reveal? Those decisions often depend on someone else's interface, index or routing service. Openness differs across protocols; saying every DEX decentralizes only settlement would be wrong. The useful question is which layer I can inspect, choose or replace.

In 2018, we also participated as an investor in incubating a decentralized exchange intended to use ArcBlock’s platform and chain. It was a stealth project. It never formally launched, although it released a mobile app. The team had substantial securities-market experience and had built a sizeable securities trading platform. We committed money, engineering effort and technical support.

It did not work out. The project closed, and our investment and effort did not come back. As I remember it, the team had become discouraged about the prospects for decentralized exchange. A market becoming important later does not mean the startups pursuing it earlier survive. Having more people, more money and more trading experience than we did did not remove that risk. This belongs in the story as a lesson, not a success.

Another experiment left a public record: packaging the Uniswap frontend as a deployable Blocklet. Our October 2020 platform update listed a Uniswap deployer Blocklet. People could run their own interface while using the corresponding Uniswap contracts. Deploying that interface did not duplicate its liquidity pools or make someone the operator of the whole protocol. It was an early attempt to put the interface in the user’s hands; its historical deployment instructions are not instructions for today’s ARC.

In November 2022, I returned to this direction in a public deck, New Architecture for A Future Decentralized Exchange. It explicitly says WIP and DRAFT. Slide 5 describes an agent accountable only to its user, slide 6 treats order books as a protocol multiple parties can implement, slide 8 puts agreed trades into atomic on-chain execution, and slide 9 examines DID, credentials and privacy. These ideas were already on the page.

The deck also shows where the thinking needed work. Its agent was primarily software acting for a user, not automatically today’s AI agent. It understated what existing chains could settle and described participant discretion over compliance too broadly. Ethereum can perform atomic settlement, and applicable law constrains both software providers and participants. What carries forward is the direction of user-owned agents and market access, not every sentence of the old draft.

Earlier systems approached different parts of this problem.

Separating a market's functions gives participants more choices about who performs them. It does not make useful intermediaries unnecessary.

A wallet needs an online counterpart

A wallet was a natural starting point for P2P exchange. Ownership and signing authority belong with the user. When two people already know each other or meet to agree on terms, that arrangement makes immediate sense.

But a wallet is not inherently always on, and it does not come with global discovery. Where does Alice's intent live after she closes her phone? How does Bob find her? Giving an online server her private key would solve availability by surrendering another form of control.

I am more interested in separating online participation from spending authority. ArcSpace can retain personal rules, state and a contact endpoint. Services running on ARC can publish selected information, discover candidates and communicate. The wallet retains authorization. The user's agent handles work between those layers that previously required someone to watch a screen.

Alice could publish the kind of asset she wants to exchange and her acceptable settlement chains without publishing every holding or her reservation price. Her agent could ask Bob, Carol, a market maker and an OTC desk, while comparing executable AMM and solver quotes. Deterministic checks precede Alice's approval and the wallet's signature. Only the agreed transaction proceeds to settlement.

That market layer covers more than a single exchange contract. It can also use a smart contract. Ethereum, Solana and ArcBlock are possible settlement choices, with different assets and liquidity. An ordinary atomic transaction still has a single-chain boundary; cross-chain execution requires additional mechanisms and assumptions.

Persistent availability needs hosting, backup and recovery. ARC does not automatically provide global order search. Quote formats, discovery protocols, spam resistance and synchronized state remain work for builders. The architectural opportunity is to give that work a place the user can own.

Your agent works for you

Brokers, exchanges and market makers exist partly because finding information, coordinating and negotiating are expensive. A person cannot continuously ask hundreds of counterparties for offers while tracking their expiry, asset conditions, fees and availability. Paying specialists to perform that work has often been the sensible choice.

Think of a frequent property investor who finds it worthwhile to obtain the relevant agent license and participate more directly in their own transactions. They need not open a brokerage, and they can still pay for professional help. Personal market tools have a similar motivation: if the overhead is low enough, I can own my representative and terminal rather than start every trade inside someone else’s interface and default rules. The user essay develops this analogy, including who might have little reason to adopt such tools.

AI may change part of that cost structure. A personal agent can make asynchronous inquiries, compare terms under personal rules and negotiate with other agents. The interesting claim is that users could own tools once practical mainly for professional intermediaries.

The user should define best execution. One person prioritizes net proceeds. Another needs a predictable completion time. Someone else will wait to reveal less about their identity or intent. Price, slippage, speed, credentials and order splitting can reflect the user's preferences rather than a platform's default ranking.

Intermediaries still have work worth paying for. A market maker commits inventory; a broker contributes a specialized network; a solver finds a better combination; an indexer provides dependable search. A user's own agent makes those services easier to compare. Control of an entrance should not determine whose definition of a good trade the user must accept.

The agent should not receive unlimited spending authority. A counterparty's message cannot rewrite my budget, and an enthusiastic model response cannot replace checks on addresses, quantities and recipients. Off-chain or selectively shared negotiation may also reduce some intent exposure and front-running opportunities. It does not eliminate MEV: final ordering, information leakage and executor behavior still matter.

We build the tools; the operator's role must remain explicit

Enabling more people to open exchanges and enabling each person to own market tools are different objectives. White-label software can lower the cost of launching an exchange. If every brand depends on the same irreplaceable custody and matching backend, the user's position may barely change. A personal market node could instead be a private terminal with no public trading website.

For now, I find the infrastructure role more compelling: software and protocols developers can combine, and services users can choose to run. That is a current direction, not a permanent promise about every future business decision. If ArcBlock later operates a particular market, custody, execution, fees and compliance responsibilities will need their own assessment. We could not keep describing that activity as merely publishing tools.

The distinction also matters legally, but it is not an exemption. Distributing tools, trading for oneself and continuously arranging trades for others are different activities. Personal deployment does not automatically remove registration, licensing or compliance obligations. Credentials can help participants assess eligibility while revealing less personal information; they do not replace those obligations. The legal essay, part of the main reading path, examines these boundaries.

For a developer, the next question is how to build a market from these primitives: start with known counterparties, then add publishing, personal agents and replaceable discovery. For someone who does not write software, it is what running a personal market Blocklet would actually mean: installing software made by others while retaining rules, records and authorization.

The complete trading scenario connects the pieces: a persistent offer, comparisons across markets, agent negotiation, wallet authorization and atomic settlement. It also examines what changes when tokens become NFTs or claims on a service. Read the legal chapter alongside those design choices; responsibility belongs in the architecture from the beginning.

My answer is therefore more specific than “no DEX.” Let the chain verify and settle, let personal infrastructure retain state, let each user's agent represent that user's interests, and let developers turn those pieces into software people can choose. ArcBlock can make markets possible without becoming the exchange everyone must pass through. That is the role I want us to build toward.