Execució d'IA: La fi de la 'IA com a text' per al programari

El panorama de la intel·ligència artificial en el desenvolupament de programari està experimentant una transformació profunda. Durant els darrers dos anys, el paradigma dominant per interactuar amb la IA implicava un intercanvi senzill: introduir text, rebre una sortida de text i, després, decidir manualment el següent curs d'acció. Aquesta era de la "IA com a text", tot i ser innovadora, ara està donant pas a un enfocament més dinàmic i integrat. Arriba el GitHub Copilot SDK, anunciant la nova era on la IA com a execució es converteix en la interfície.

El programari de producció es basa inherentment en l'execució: planificar passos, invocar eines, modificar fitxers, recuperar-se d'errors i adaptar-se a les restriccions. Aquestes són operacions complexes de diversos passos que la mera generació de text no pot abastar completament. El GitHub Copilot SDK aborda directament aquesta bretxa, posant a disposició la potent capa d'execució que sustenta el GitHub Copilot CLI com una capacitat programable dins de qualsevol aplicació de programari. Això significa que els equips poden incrustar motors de planificació i execució provats en producció directament als seus sistemes, alterant fonamentalment la manera com s'arquitecten i operen les aplicacions impulsades per IA.

De Scripts Estàtics a Fluxos de Treball Agentics Adaptatius

El desenvolupament de programari tradicional ha confiat durant molt de temps en scripts i codi "cola" per automatitzar tasques repetitives. Tot i ser efectives per a seqüències fixes, aquestes solucions es tornen ràpidament fràgils quan s'enfronten a matisos contextuals, canvis a mig execució o la necessitat d'una recuperació d'errors robusta. Els desenvolupadors sovint es troben programant casos extrems o construint capes d'orquestració a mida, un esforç que consumeix molt de temps i sovint insostenible.

El GitHub Copilot SDK allibera les aplicacions d'aquestes restriccions permetent-los delegar la intenció en lloc de codificar explícitament cada pas. Imagineu una aplicació que necessita "Preparar aquest repositori per al llançament". En lloc d'un script rígid, el Copilot SDK permet a un agent d'IA:

Explorar l'estructura i el contingut del repositori.
Planificar els passos necessaris, com actualitzar la documentació, executar proves o augmentar els números de versió.
Modificar fitxers segons sigui necessari.
Executar ordres dins de l'entorn del sistema.
Adaptar-se dinàmicament si algun pas falla o si sorgeix nova informació, tot operant dins dels límits i permisos predefinits.

Aquest canvi és crucial per als sistemes de programari moderns. A mesura que les aplicacions escalen i els entorns evolucionen, els fluxos de treball fixos són propensos a fallar. L'execució agentica, impulsada pel Copilot SDK, permet que el programari s'adapti i es corregeixi automàticament, mantenint l'observabilitat i les restriccions sense la càrrega constant de reconstruir una orquestració complexa des de zero. Això fa de la IA un participant actiu i intel·ligent en el cicle de vida del desenvolupament, anant més enllà de la finalització bàsica del codi fins a l'automatització intel·ligent de tasques. Per obtenir més informació sobre com es garanteixen aquests fluxos de treball complexos, exploreu l'arquitectura de seguretat dels fluxos de treball agentics de GitHub.

Context Estructurat per a una IA Fiable: El Model Context Protocol (MCP)

Un error comú en l'era de la "IA com a text" era l'intent d'introduir massa comportament i dades del sistema en els prompts d'IA. Tot i que semblava convenient, codificar la lògica en text fa que els fluxos de treball siguin difícils de provar, raonar i evolucionar. Amb el temps, aquests prompts elaborats es converteixen en substituts fràgils d'una integració de sistemes estructurada adequada.

El GitHub Copilot SDK aborda això amb un enfocament estructurat i composable del context, aprofitant el Model Context Protocol (MCP). Amb el MCP, els desenvolupadors poden:

Definir eines o habilitats d'agent específiques del domini que la IA pot invocar.
Exposar aquestes eines i habilitats mitjançant el MCP.
Permetre que el motor d'execució recuperi dinàmicament el context en temps d'execució.

Això significa que la informació crítica —com dades de propietat del servei, esquemes d'API, registres de decisions històriques, gràfics de dependències o API internes— ja no necessita ser forçada als prompts. En canvi, els agents accedeixen a aquests sistemes directament durant les seves fases de planificació i execució. Per exemple, un agent intern encarregat de resoldre un problema podria consultar automàticament la propietat del servei, extreure dades històriques rellevants, comprovar els gràfics de dependències per a l'avaluació d'impacte i fer referència a les API internes per proposar solucions, tot respectant les restriccions de seguretat definides. Aquest enfocament contrasta clarament amb els reptes de les bones pràctiques per a l'enginyeria de prompts amb l'API d'OpenAI on la injecció de context pot ser complexa.

Per què és important: Els fluxos de treball d'IA fiables es basen en un context fonamentat, amb permisos i estructurat. El MCP proporciona la infraestructura crucial, garantint que l'execució agentica operi amb eines i dades reals, eliminant les suposicions i la fragilitat associades a l'enginyeria de prompts basada en text.

IA com a Infraestructura: Incrustant l'Execució Més enllà de l'IDE

Històricament, gran part de les eines d'IA per a desenvolupadors s'han confinat a l'Entorn de Desenvolupament Integrat (IDE). Tot i ser inestimables per a la codificació, els ecosistemes de programari moderns s'estenen molt més enllà d'un únic editor. Els equips requereixen capacitats agentics en una multitud d'entorns: aplicacions d'escriptori, eines operatives internes, serveis en segon pla, plataformes SaaS i sistemes basats en esdeveniments.

El Copilot SDK trenca aquestes barreres, fent de l'execució una capacitat a nivell d'aplicació. Això significa que el vostre sistema ara pot escoltar esdeveniments —un canvi de fitxer, un disparador de desplegament, una acció de l'usuari— i invocar programàticament Copilot per iniciar un flux de treball agentic. El bucle de planificació i execució s'executa dins del vostre producte, no com una interfície separada o una eina de desenvolupador.

Característica	Era de la "IA com a text"	Era de la "IA com a execució" (Copilot SDK)
Interacció	Entrada de text, sortida de text	Bucles d'execució programables
Flux de Treball	Decisió manual, scripts fràgils	Agents adaptatius, d'autocorrecció
Context	Sovint incrustat en prompts (fràgil)	Estructurat mitjançant MCP, recuperació en temps real
Integració	Intercanvis aïllats, centrats en IDE	Incrustat a qualsevol lloc (app, servei, SaaS)
Rol del Desenvolupador	Enginyeria de prompts, orquestració manual	Definició d'intenció, restriccions, eines
Principi Bàsic	La IA assessora, l'humà executa	La IA planifica i executa, l'humà supervisa

Per què és important: Quan l'execució de la IA s'incrusta directament a la vostra aplicació, deixa de ser un ajudant útil i es converteix en una infraestructura fonamental. Està disponible allà on s'executi el vostre programari, estenent el poder de la IA a cada racó de les vostres operacions digitals, fomentant un paisatge de programari veritablement intel·ligent i adaptatiu.

El Canvi Arquitectònic: IA Programable i el Futur

El pas de la "IA com a text" a la "IA com a execució" representa una evolució arquitectònica significativa. Significa un paradigma on els agents d'IA no només generen fragments, sinó que són bucles de planificació i execució programables capaços d'operar sota restriccions definides, integrar-se perfectament amb sistemes reals i adaptar-se intel·ligentment en temps d'execució.

El GitHub Copilot SDK és el facilitador clau d'aquest futur. En fer accessibles aquestes sofisticades capacitats d'execució com una capa programable, permet als equips de desenvolupament centrar-se en el "què" de més alt nivell que el seu programari ha d'aconseguir, en lloc de reconstruir constantment el "com" subjacent de l'orquestració d'IA. Aquest canvi transforma la IA d'una utilitat nova en un component fonamental i indispensable de l'arquitectura de programari moderna, prometent aplicacions més resilients, autònomes i intel·ligents en general. Si la vostra aplicació pot activar lògica, ara pot activar l'execució agentica, donant pas a una nova era de programari veritablement intel·ligent.

Font original

https://github.blog/ai-and-ml/github-copilot/the-era-of-ai-as-text-is-over-execution-is-the-new-interface/

Preguntes freqüents

What is the core shift from 'AI as text' to 'AI as execution' introduced by the GitHub Copilot SDK?

The fundamental shift signifies a move from AI systems that merely generate text output from text input, requiring manual human intervention for the next steps, to systems where AI can actively plan, execute, adapt, and recover from errors within a predefined set of constraints. This means AI transitions from a passive assistant to an active participant, capable of orchestrating complex, multi-step operations directly within software applications, making it a functional component rather than just a conversational interface. The Copilot SDK provides the tools to embed this execution layer into any application.

How does the GitHub Copilot SDK enable sophisticated agentic workflows within applications?

The GitHub Copilot SDK empowers applications by providing access to the same production-tested planning and execution engine that drives GitHub Copilot CLI. Instead of building complex orchestration stacks from scratch, developers can embed this SDK to delegate intent to AI agents. These agents can explore repositories, plan necessary steps, modify files, run commands, and adapt to unforeseen issues—all while respecting defined boundaries. This allows software to become more adaptive and resilient, moving beyond rigid, scripted workflows to dynamic, context-aware operations.

What is the Model Context Protocol (MCP) and why is it crucial for grounded AI execution?

The Model Context Protocol (MCP) is a vital component that enables structured and composable context for AI agents. Rather than embedding critical system logic and data within prompts—a practice that leads to brittle, hard-to-test workflows—MCP allows applications to define domain-specific tools and agent skills. The execution engine then uses MCP to retrieve relevant context directly at runtime, such as service ownership data, API schemas, or dependency rules. This ensures that AI agents operate on real, permissioned data and systems, preventing guesswork and making AI workflows more reliable and maintainable.

Beyond the Integrated Development Environment (IDE), where can the GitHub Copilot SDK embed AI execution?

The GitHub Copilot SDK liberates AI execution from being confined primarily to the IDE, allowing it to function as a pervasive application-layer capability. This means agentic capabilities can be seamlessly integrated into a wide array of environments, including desktop applications, internal operational tools, background services, SaaS platforms, and event-driven systems. By enabling applications to programmatically invoke Copilot upon specific events—like a file change, deployment trigger, or user action—the SDK transforms AI from a mere helper in a side window into core infrastructure that operates wherever the software runs.

What are the primary benefits of delegating multi-step tasks to AI agents using the Copilot SDK?

Delegating multi-step tasks to AI agents via the Copilot SDK offers significant advantages over traditional scripting. It allows software to handle workflows that are context-dependent, change dynamically mid-run, or require robust error recovery, which typically break down fixed scripts. By delegating 'intent' rather than explicit steps, agents can autonomously explore, plan, execute, and adapt within defined constraints. This leads to more scalable, adaptable, and observable systems, freeing developers from continually rebuilding bespoke orchestration layers for complex, evolving processes.

How does the Copilot SDK improve the reliability and adaptability of AI-powered systems?

The Copilot SDK enhances reliability and adaptability by providing a robust execution layer and integrating structured context. Its production-tested planning and execution engine ensures agents can plan complex operations, execute commands, modify files, and recover from errors, making systems more resilient. Furthermore, by utilizing the Model Context Protocol (MCP), agents access real-time, structured, and permissioned context—like API schemas or dependency graphs—rather than relying on potentially outdated or generalized prompt information. This grounding in real data ensures agents make informed decisions, reducing errors and increasing the system's ability to adapt to changing conditions and constraints.

Is the GitHub Copilot SDK primarily for professional developers, or can others benefit from its capabilities?

While the GitHub Copilot SDK is designed to empower professional developers by extending agentic AI capabilities into their applications and infrastructure, its benefits ripple outwards. By enabling AI to handle complex, multi-step tasks and integrate directly into various software systems, it streamlines workflows, reduces manual effort, and enhances the adaptability of applications. This ultimately benefits end-users and organizations by leading to more efficient, intelligent, and robust software, even if the direct interaction with the SDK is primarily on the developer's side. The SDK makes AI a fundamental infrastructure component across the software ecosystem.

Manteniu-vos al dia

Rebeu les últimes notícies d'IA al correu.