TUNQIHN0YSBkaXZlbnRhbmRvIHNlbXByZSBwacO5IGRpIHRlbmRlbnphLCBpbCBzZXR0b3JlIGRlZ2xpIGFnZW50aSBBSSBzdGEgZGl2ZW50YW5kbyB2aXJhbGUgZGkgbnVvdm8/

<p><img src="https://gimg2.gateimg.com/image/article/1745896279HOTSPOT.png" alt=""></p>
<h2 id="h2-TLDR206851"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Il settore degli agenti AI è aumentato del 32% negli ultimi sette giorni, con la sua capitalizzazione di mercato che è salita a $5.6B, e l’attenzione del mercato è aumentata drasticamente.</p>
<p>Diversi protocolli AI Agent come Swarms, .fun e SKYAI hanno lanciato servizi MCP, ma la maggior parte di essi si trova nelle fasi iniziali in cui i concetti superano la pratica e i loro prodotti non sono molto maturi.</p>
<p>Se MCP vuole diventare l’“HTTP” dell’IA, la sicurezza e la compatibilità devono venire prima di tutto.</p>
<h2 id="h2-Introduzione954220"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Since last week, the <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> ha visto un lungamente atteso rimbalzo, con il valore di mercato complessivo che è aumentato significativamente e il sentiment degli investitori migliorato notevolmente. In questo rimbalzo, il settore degli Agenti di Intelligenza Artificiale ha ottenuto particolari risultati, con un aumento del 42,3% negli ultimi sette giorni e un valore di mercato di $6.1B, con un’attenzione di mercato in netto aumento. Questo articolo spiega la logica tecnica che guida MCP e ACP.</p>
<h2 id="h2-Il20settore20degli20agenti20di20intelligenza20artificiale20guida20la20crescita20e20leffetto20catalitico20di20MCP20inizia20a20emergere940112"><a name="Il settore degli agenti di intelligenza artificiale guida la crescita, e l’effetto catalitico di MCP inizia a emergere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il settore degli agenti di intelligenza artificiale guida la crescita, e l’effetto catalitico di MCP inizia a emergere</h2><p>MCP sta ridefinendo la narrazione del valore di AI Agent e sta guidando l’attuale forte crescita di questo settore. Ho menzionato in molti post del blog che discutono della recessione di mercato che l’integrazione di AI e blockchain sarà uno dei trend importanti in futuro <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato criptato</a>, e l’ascesa predominante del settore dell’AI questa volta fornisce indubbiamente prove tangibili a sostegno di questa visione. In questa ondata di crescita del settore dell’AI, la tecnologia MCP ha senza dubbio svolto il ruolo di un catalizzatore.<br><img src="https://gimg2.gateimg.com/image/article/17458965041.jpeg" alt=""><br>Source: coingecko</p>
<p>MCP (Model Context Protocol) è progettato per risolvere il problema della frammentazione quando i modelli di intelligenza artificiale interagiscono con strumenti esterni e fonti di dati. In parole semplici, MCP è simile a una “spina universale” per l’IA, che consente ai modelli di connettersi in modo sicuro e standard a basi di dati, sistemi di file o API di terze parti per ottenere dati in tempo reale e svolgere compiti. La sua comparsa coincide con il momento critico in cui gli Agenti di intelligenza artificiale passano da “comprendere” a “eseguire”.</p>
<p>In altre parole, il ruolo importante di MCP è che amplia gli scenari di applicazione dell’agente AI. In passato, i modelli AI erano principalmente strumenti off-chain che interagivano con la blockchain tramite API, che erano inefficienti e limitati da interfacce centralizzate. Oggi, MCP fornisce ai modelli AI un’identità on-chain e consapevolezza contestuale, consentendo loro di funzionare come “esecutori cognitivi on-chain.” Ad esempio, in DeFi, i market maker AI possono utilizzare MCP per analizzare la profondità del libro degli ordini e gli indicatori di sentimento cross-chain in tempo reale, regolare dinamicamente la pianificazione della liquidità e sostituire i modelli statici tradizionali. Questa praticità ha dato al mercato un’opportunità, e i fondi hanno iniziato a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">flusso</a> nel settore dell’IA.</p>
<table>
<thead>
<tr>
<th>Dimensione della funzionalità</th>
<th>MCP</th>
<th>Tradizionale <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> protocollo</th>
<th>middleware AI (come Langchain)</th>
</tr>
</thead>
<tbody>
<tr>
<td>Orientato agli oggetti</td>
<td>modelli AI</td>
<td>Utente &amp; futures</td>
<td>Sviluppatori &amp; modelli</td>
</tr>
<tr>
<td>Gestione del contesto</td>
<td>Astrazione del contesto on-chain</td>
<td>Lo stato di conservazione è il principale</td>
<td>Ragionamento semantico</td>
</tr>
<tr>
<td>Progettazione architettonica</td>
<td>Strato di protocollo strutturato + strato semantico</td>
<td>Processo orientato agli asset/commercio</td>
<td>Framework di integrazione degli strumenti</td>
</tr>
<tr>
<td>Componibilità del modello</td>
<td>Supporto collaborazione multi-agente</td>
<td>Chiamate di stato solo</td>
<td>Limitato ai dati locali</td>
</tr>
<tr>
<td>Compatibilità dell’ecosistema</td>
<td>Alto, può essere inserito in qualsiasi catena</td>
<td>Medio</td>
<td>Basso, adatto solo a modelli specifici</td>
</tr>
<tr>
<td>Potenziali utenti</td>
<td>Fornitore di modelli AI/ Piattaforma per casi d’uso</td>
<td>Utenti DeFi/DAO</td>
<td>AI Startups</td>
</tr>
</tbody>
</table>
<p>Origine: @Lawrence</p>
<p>Da un punto di vista più ampio, il rimbalzo del <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> e la crescita del settore dell’IA non sono eventi isolati. L’avanzamento della tecnologia dell’IA fornisce una base per le applicazioni on-chain, mentre la natura decentralizzata della blockchain fornisce un framework di fiducia e incentivi per l’IA. MCP, come ponte, colma il divario tecnologico e accende l’immaginazione degli investitori. Pertanto, nel mercato crittografico, che afferma di essere valutato al tasso del sogno di mercato, esiste naturalmente un prerequisito per alimentare l’ipotesi del settore degli Agenti IA.</p>
<h2 id="h2-Analisi20del20caso20di20utilizzo20di20MCP20bassa20maturit20del20prodotto20e20bolle20in20aumento958725"><a name="Analisi del caso di utilizzo di MCP: bassa maturità del prodotto e bolle in aumento" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi del caso di utilizzo di MCP: bassa maturità del prodotto e bolle in aumento</h2><p>Per comprendere meglio l’applicazione pratica del protocollo MCP, condividiamo alcuni protocolli dell’Agente AI che hanno adottato MCP.</p>
<p>Swarms: Framework di collaborazione multi-agente di livello enterprise Swarms ha recentemente lanciato un server MCP per gli scambi per implementare l’analisi dei dati dei token e l’esecuzione automatica delle transazioni all’interno del framework swarms-rust pronto per la produzione. Il team ha ora integrato strumenti di valutazione dei compiti opzionali nel framework degli agenti.<img src="https://gimg2.gateimg.com/image/article/17458968202.jpeg" alt=""><br>Fonte: @swarms_corp</p>
<p>.fun: La piattaforma dati dell’agente AI di .fun ha recentemente lanciato il proprio server MCP, fornendo agli sviluppatori e al personale non tecnico un server MCP specifico dell’agente plug-and-play. Gli utenti possono facilmente creare e distribuire i propri agenti AI senza alcuna configurazione complessa.</p>
<p>DeMCP: Un live <a href="/web3" rel="nofollow noopener noreferrer" target="_blank">Web3</a> Mercato MCP che fornisce accesso scontato a modelli linguistici di grandi dimensioni come GPT-4 e Claude. A differenza dei tradizionali metodi di accesso ai servizi AI, DeMCP utilizza un ambiente di esecuzione affidabile (TEE) e meccanismi di sicurezza on-chain per garantire la sicurezza e la privacy dei dati. Ciò significa che gli utenti possono usufruire dei servizi AI senza preoccuparsi di perdite o abusi di dati.</p>
<p>SkyAI: SkyAI, basato sul <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, fornisce accesso ai dati multi-chain e distribuzione dell’agente AI. Il progetto combina in modo creativo MCP con proof a conoscenza zero, permettendo agli agenti AI di implementare l’audit dei contratti intelligenti, il tracciamento dei token e l’analisi cross-chain.<img src="https://gimg2.gateimg.com/image/article/17458968513.jpeg" alt=""><br>Origine: @SKYAIpro</p>
<p>Abbiamo presentato questo progetto nell’articolo della settimana scorsa, <a href="https://www.gate.io/blog/7298/will-bnb-chain-link-the-sol-chain-to-revive-the-on-chain-eco" target="_blank">“La catena BNB collegherà la catena SOL per ravvivare l’ecosistema on-chain?”</a> Il pre-sale di SKYAI ha attirato oltre 110.000 indirizzi per partecipare, raccogliendo un totale di 83.848 <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>(circa 50 milioni di dollari). Dopo il TGE ufficiale, il valore di mercato è salito fino a un massimo di 76 milioni e l’effetto hype di mercato era evidente.</p>
<p>Dark: DARK è un ecosistema progettato per agenti di intelligenza artificiale che integra sistemi economici e infrastrutture tecniche. Il suo obiettivo è costruire un’infrastruttura di rete che supporti chiunque a creare, ospitare e trarre profitto dai servizi MCP. Attualmente gestisce due MCP:</p>
<ul>
<li>Dark Forest MCP: Dark Forest MCP fornisce a SPUTNIK (un agente AI competitivo di DARK Games) la capacità di esplorare aree sconosciute in mappe nebbiose, analizzare le proprie coordinate e pianificare percorsi di salto tra pianeti.</li><li><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> MCP: Fornisce tutte le funzionalità per interagire con il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain.</li></ul>
<p>Altri progetti, come l’integrazione di AWS di OpenServ, l’Agent Studio di Holoworld e la capacità di ordinare la pizza attraverso MCP e Claude di ElevenLabs, hanno tutti raggiunto importanti traguardi in scenari segmentati.</p>
<p>Tuttavia, la maggior parte dei MCP sia in Web2 che in <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> sono ancora nelle prime fasi e sono più concettuali che pratici, in particolare molti protocolli AI Agent che utilizzano MCP come punto vendita, ma la maturità del prodotto non è alta. In questa fase, quando la bolla concettuale è esaltata, dobbiamo comunque prestare attenzione a quei protocolli che possono atterrare e portare aggiornamenti di valore.</p>
<h2 id="h2-MCP20Ha20Ancora20Pericoli20Nascosti20Quali20Altre20Carte20Possono20Giocare20Gli20Agenti20AI414216"><a name="MCP Ha Ancora Pericoli Nascosti, Quali Altre Carte Possono Giocare Gli Agenti AI?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MCP Ha Ancora Pericoli Nascosti, Quali Altre Carte Possono Giocare Gli Agenti AI?</h2><p>Anche se il protocollo MCP ha mostrato un grande potenziale per l’applicazione e le prospettive di mercato nel <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a>, affronta comunque numerose sfide e pericoli nascosti sul suo percorso di sviluppo.</p>
<p>In primo luogo, la popolarità di MCP non è abbastanza elevata e molti grandi servizi di intelligenza artificiale devono ancora integrare MCP. In particolare, il supporto per MCP da parte di diversi sistemi e piattaforme è limitato, il che a sua volta limita ulteriormente lo sviluppo di MCP nel mercato criptato.</p>
<p>Inoltre, l’apertura di MCP porterà anche alcuni problemi di perdita di privacy. Ad esempio, 23pds di SlowMist Technology ha avvertito che MCP potrebbe avere falle, e gli hacker possono far trapelare la cronologia delle conversazioni degli utenti manipolando il sistema di intelligenza artificiale. Infatti, essendo un protocollo aperto, MCP deve gestire l’interazione di diverse fonti di dati, aumentando così la superficie di attacco. Gli hacker potrebbero effettivamente raggiungere scopi maliziosi falsificando richieste o manipolando dati. Ad esempio, quando un Agente IA accede ai dati on-chain, se il server viene compromesso, i dati degli utenti potrebbero essere rubati. Inoltre, quando gli utenti autorizzano un Agente IA ad accedere a informazioni sensibili, se un terzo accede senza autorizzazione, la tendenza violerà gravemente la privacy.<img src="https://gimg2.gateimg.com/image/article/17458969334.jpeg" alt=""><br>Source: @trailofbits</p>
<p>In altre parole, l’infrastruttura dell’agente AI <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> non è perfetta, e i “buchi” come il livello dei dati e il livello dell’oracolo non sono stati riempiti. Se MCP si espande ciecamente, potrebbe amplificare la vulnerabilità del sistema. Il valore della tecnologia risiede nella robustezza. Se MCP vuole diventare l’”HTTP” dell’AI, la sicurezza e la compatibilità devono venire prima.</p>
<p>Di fronte alla crisi di fiducia che circonda MCP, il protocollo emergente ACP (Agent Commerce Protocol) offre una possibilità alternativa. Diversamente dal posizionamento di “adattamento tecnico” di MCP, ACP si concentra sulla costruzione di uno strato di regolamento commerciale decentralizzato e introduce il meccanismo di “Proof of Intent” per garantire che il comportamento dell’agente sia completamente coerente con gli obiettivi dell’utente.</p>
<p>In sintesi, secondo me, il futuro dell’Agente AI potrebbe muoversi verso un’architettura “a strati di protocollo”: MCP è responsabile delle connessioni tecniche, ACP gestisce lo scambio di valore e lo strato sottostante richiede supporto infrastrutturale come l’identità distribuita (DID) e lo storage decentralizzato (come IPFS).<img src="https://gimg2.gateimg.com/image/article/17458969675.jpeg" alt=""><br>Origine: @DeMCP_AI</p>
<p>Naturalmente, l’attuale tendenza degli agenti di intelligenza artificiale e persino l’integrazione di intelligenza artificiale e criptovalute è ancora in fase di evoluzione tecnologica e di discussione tra più parti, e la direzione non è ancora chiara. Tuttavia, l’autore ha sempre creduto che solo posizionando l’efficienza degli utenti e le esigenze di privacy al centro della logica sottostante si possa stimolare un maggior valore economico. L’autore è anche disposto a comunicare con voi per discutere ulteriori intuizioni e osservazioni in questo campo.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Charle Y.</strong>, Ricercatore di Gate.io<br><div>Translator:Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Il ripostaggio dell'articolo sarà consentito a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>