Wat is Agent Bricks?

Agent Bricks is het Azure Databricks agent ontwikkelplatform voor agenten. Gebruik het om de agents te bouwen en uit te rollen die je AI-agentproducten en workflows aandrijven. Agent Bricks is gemaakt voor ontwikkelaars die code schrijven. Je brengt een agent mee die gebouwd is met elk framework of testharnas en kiest elk model.

Agent Bricks ondersteunt de kernworkflows voor het bouwen van een productieagent:

• Deploy je agent: Agent Runtime host agents die zijn gebouwd met elk framework of tooling, stateful of stateless, en AgentKit voegt duurzame uitvoering toe zodat uitvoeringen herstarts en crashes overleven.
• Code veilig uitvoeren: Agenten voeren de code uit die ze schrijven in Databricks Sandbox, een geïsoleerde omgeving waarvan de thuismap over sessies heen blijft bestaan.
• Verrijk de context van je agent:Agentgeheugen en sessies laten je agent herinneren wat hij in eerdere gesprekken heeft geleerd, zodat hij antwoorden kan personaliseren en tokenkosten kan verlagen.
• Debug en test je agent: MLflow Tracing registreert elke stap die je agent neemt, en je kunt traces op schaal opslaan en beheren in Unity Catalog.

De Agent Bricks CLI genereert agentcode die verbinding maakt met deze diensten. Je kunt lokaal itereren, ook met coding agents, en dan je agent inzetten.

Hoe Agent Bricks zich verhoudt tot andere Azure Databricks-aanbiedingen:

• Genie Agents: Genie Agents is bedoeld om agenten zonder code te creëren, zoals agenten die vragen beantwoorden via je tabellen en documenten. Agent Bricks is bedoeld voor ontwikkelaars die hun eigen agentcode schrijven. Een custom agent kan Genie Agents als hulpmiddelen inschakelen.
• Genie One: Genie One is bedoeld voor zakelijke gebruikers die vragen willen stellen over data, dashboards willen bekijken en apps willen gebruiken zonder code te schrijven. Agent Bricks is bedoeld voor ontwikkelaars die de agenten zelf bouwen. Een aangepaste agent kan Genie One als hulpmiddel aanroepen om gebruik te maken van je bedrijfscontext.
• Omnigent: Omnigent is een meta-orkestrator die meerdere agenten, zoals codeeragenten, samenstelt en coördineert. Je kunt Omnigent gebruiken om een aangepaste agent te ontwikkelen die je deployt en draait op Agent Bricks.

Componenten van een agent

Een agent is een AI-systeem dat een verzoek waarneemt, beslist wat te doen en handelt om een doel te bereiken. In tegenstelling tot een enkele modelaanroep voert een agent een lus uit. Het gebruikt een model om over het verzoek te redeneren, roept tools aan om informatie te verzamelen of acties te ondernemen, observeert de resultaten en herhaalt dit totdat het kan reageren.

Een productieagent combineert doorgaans de volgende componenten:

• Agent loop (framework ofwel harness): Jouw code. De agent-lus is gebouwd met een framework of raamwerk zoals LangGraph of de OpenAI Agents SDK, en bevat de instructies en orkestratielogica die bepalen hoe de agent zich gedraagt.
• Model: Het grote taalmodel (LLM) dat over elke stap redeneert en bepaalt welke actie daarna wordt ondernomen.
• Tools: Functies die de agent aanroept om data op te halen, inclusief je bedrijfsgegevens, of om de status van een ander systeem te wijzigen. Voorbeelden zijn Model Context Protocol (MCP)-servers, API's en sandboxes die de code uitvoeren die de agent schrijft.
• Agentstatus: Wat de agent bijhoudt. Agentstatus omvat de huidige sessie, dat is het gesprek of de lopende taak, en geheugen, wat de agent leert en zich herinnert tussen sessies.
• Agentserver: De bibliotheek die de agentlus in een HTTP-server omhult. Het maakt de API beschikbaar die clients aanroepen, beheert clientverbindingen en regelt duurzaamheid door de status van elke run in een Runtime Store te houden.
• Agent runtime: De beheerde rekenomgeving die de agentserver draait en hosting, identiteit en schaalverdeling verzorgt.
• Observabiliteit: Traces die elke stap die de agent zet vastleggen, en evaluaties die meten of de output goed is.
• Governance: Identiteit, permissies en beleidsregels die bepalen welke modellen, tools en data de agent mag gebruiken.

Het framework of het harness, de agentserver en de agentruntime vormen samen de agent-computestack. Zie Deploy agents on Azure Databricks.

Uitdagingen bij het bouwen van agenten in productie

Een prototype-agent kan op een middag op een laptop draaien. Agenten betrouwbaar laten draaien voor echte gebruikers is moeilijker. Teams die agenten zelf bouwen besteden vaak het grootste deel van hun tijd aan het assembleren en beheren van infrastructuur in plaats van het verbeteren van de agent. De algemene uitdagingen kunnen in vijf gebieden worden onderverdeeld:

• Modeltoegang: Teams moeten kiezen tussen frontier- en open modellen, modellen wisselen of upgraden zonder code te herschrijven, en voldoende capaciteit op productieschaal krijgen, terwijl ze kosten en toegang beheersen.
• Compute: Agenten hebben compute nodig die schaalbaar is met het verkeer, langlopend werk levend houdt door herstarts en storingen, en elke sessie isoleert. Agenten die code schrijven en draaien, hebben een veilige plek nodig om het te draaien.
• Context: Agenten geven betere antwoorden wanneer ze op het juiste moment de juiste data hebben. Dat vereist een duurzame conversatietoestand, geheugen dat over sessies heen blijft bestaan, en veilige toegang tot bedrijfsdata en tools zonder data te kopiëren of inloggegevens te delen.
• Kwaliteit: Agenten produceren open, niet-deterministische output, dus "goed" is moeilijk te definiëren en te meten. Zonder traceren en evaluatie kunnen teams geen fouten debuggen, kwaliteit aan stakeholders bewijzen of regressies in productie opsporen.
• Governance en controle: Agenten handelen op basis van data en roepen externe services aan. Zonder uniforme rechten, beleidsregels en gebruikstracking lopen organisaties het risico op datalekken, compliance-tekortkomingen, ongeoorloofd gebruik en onverwachte kosten. Teams willen ook voorkomen dat hun agenten vastzitten aan één modelprovider of cloud.

Hoe Agent Bricks deze uitdagingen aanpakt

Agent Bricks levert een beheerd bouwblok voor elke laag van de stack. De componenten delen één identiteits- en governancemodel en werken samen, maar je kunt elk onderdeel ook afzonderlijk gebruiken. Je houdt je framework, harnas en modelkeuzes aan.

Begin met de Agent Bricks CLI

De Agent Bricks CLI biedt een begeleid pad van een lege directory naar een gedeployeerde agent. Het scaffoldt een project vanuit een frameworktemplate, draait de agent lokaal en deployt deze met modeltoegang, geheugen, sessies, tools en tracering die al geconfigureerd zijn. Een declaratief agent.toml bestand legt de beheerde bronnen vast waar de agent van afhankelijk is. Om je eerste agent te bouwen, zie Agent Bricks quickstart.

Models

Unity Gateway geeft jouw agent één API voor frontier- en open modellen, inclusief modellen die Azure Databricks host via Foundation Model API's en modellen van externe providers. Je kunt van model wisselen zonder de agentcode te veranderen. Unity Gateway beheert ook de MCP-servers en skills die je agenten gebruiken, en past snelheidslimieten, beveiligingsmaatregelen en gebruikstracking toe op de verzoeken die erdoorheen gaan.

Berekenen

• Agentserver: DurableAgentServer omsluit je agentloop en bedient de aanroep-API, met synchronous, streaming- en achtergrondverzoeken, persistent run state en crashherstel. Agenten die je maakt met de Agent Bricks CLI, gebruiken deze standaard.
• Agent runtime: Agent Runtime draait de agentserver op Databricks Apps op een stabiel, geauthenticeerd eindpunt. agentbricks deploy voorziet in de middelen die je agent nodig heeft en geeft hem er toegang toe. Om een geïmplementeerde agent te bevragen, zie Agents bevragen die zijn geïmplementeerd op Azure Databricks.

• Databricks Sandbox: Databricks Sandbox is een tool die je agent aanroept om de code die hij schrijft uit te voeren in een geïsoleerde omgeving, met beperkte toegang tot je beheerde data.

Om te leren hoe deze lagen in elkaar passen, zie Agents implementeren op Azure Databricks.

Context

• Geheugenbeheer en sessies: Sessies slaan de status van een gesprek of taak op, en geheugen slaat de feiten en voorkeuren op die een agent zich later in gesprekken herinnert. Beide zijn managed stores die worden ondersteund door Lakebase en werken met elk framework. Zie Agentgeheugen en sessies.
• Gecombineerde zakelijke context met Genie One: De Genie One MCP-server geeft je agent de gecombineerde zakelijke context van je organisatie. De agent stelt een vraag in natuurlijke taal, en Genie beantwoordt deze binnen je beheerde data, waarbij Genie Ontology wordt gebruikt om zakelijke termen, metriekdefinities en tabelrelaties op te lossen. Unity Catalog-rechten zijn van toepassing, dus de agent kan alleen data opvragen die hij mag benaderen. Om het toe te voegen aan een Agent Bricks CLI-project, voer agentbricks tools add genie-one uit
• Tools en MCP-servers: Verbind agenten met door Azure Databricks beheerde MCP-servers voor Genie Agents, AI Search, Unity Catalog-functies en SQL, of met aangepaste en externe MCP-servers. Zie MCPs.
• AI Search: Haal relevante ongestructureerde inhoud op met Databricks AI Search, inclusief voor retrieval-augmented generation (RAG) toepassingen.
• Bedrijfsdata: Baseer agents op de tabellen, bestanden en Genie Agents die jouw organisatie al beheert in Unity Catalog.

Observabiliteit en kwaliteit

Azure Databricks-managed MLflow biedt tracering, evaluatie en monitoring voor agenten. MLflow Tracing registreert elke stap die een agent neemt, zowel in ontwikkeling als in productie. Evaluatie maakt gebruik van ingebouwde LLM-beoordelaars, aangepaste scoremodellen en deskundige feedback om kwaliteit te meten, en productiemonitoring detecteert regressies. Je kunt traces opslaan in Unity Catalog en ze op schaal analyseren. Zie Wat is agent-observabiliteit en kwaliteit?

Bestuur en controle

• Geïntegreerd beheer: Unity Catalog beheert de data, tools, modellen en agenten die je agenten gebruiken, met machtigingen en herkomst.
• Beleid voor modellen, MCP-servers en vaardigheden: Unity Gateway regelt de toegang tot modellen, MCP-servers en vaardigheden, en handhaaft guardrails, ratelimieten en gebruikstracking voor de aanroepen die erdoor worden gerouteerd.
• Keuze: Gebruik elk framework of harness en elk model, en wissel van model zonder je agent te herschrijven.

Levenscyclus van de ontwikkeling van agents

Het bouwen van een productieagent is iteratief. De volgende stappen beschrijven een typische levenscyclus.

1. Definieer de use case en succescriteria: Stem af wat de agent moet doen, wie het gebruikt en hoe je kwaliteit, kosten en latentie meet. Verzamel voorbeeldverzoeken en verwachte antwoorden vroegtijdig.
2. Bouw een eerste agent: Begin met het minst complexe ontwerp dat werkt. Verbind de agent met modellen, MCP-servers en vaardigheden via Unity Gateway en draai het lokaal.
3. Evalueer en itereer op kwaliteit: Gebruik traces om gedrag te debuggen, bouw een evaluatiedataset op basis van echte verzoeken en deskundige feedback, en voer evaluaties uit om het effect van elke wijziging op prompts, tools of modellen te meten.
4. Implementeren: Implementeer de agentserver naar de agentruntime, met de stores, tools en permissies die de agent nodig heeft.
5. Monitor en verbeter in productie: Monitor de kwaliteit met productietraces en scorers, verzamel gebruikersfeedback en voer wat je leert terug in de evaluatie.

Agent Bricks en andere Agent-aanbiedingen op Azure Databricks

• Genie One: De Azure Databricks-ervaring voor zakelijke gebruikers om vragen te stellen over data in natuurlijke taal, dashboards te bekijken en apps te gebruiken, zonder code te schrijven. Een custom agent gebouwd op Agent Bricks kan Genie One oproepen als een tool. Om het toe te voegen aan een Agent Bricks CLI-project, voer agentbricks tools add genie-one uit
• Genie Agents: Een low-code manier om agenten te bouwen die vragen beantwoorden via je tabellen en documenten. Gebruik Genie Agents als je geen aangepaste agentcode nodig hebt. Je maatwerkagenten kunnen ook Genie Agents als hulpmiddelen inschakelen.
• Omnigent: Een meta-framework voor het samenstellen van en samenwerken met agenten, zoals het combineren van coderingsagenten. Je kunt Omnigent gebruiken om aangepaste agenten te ontwikkelen die draaien op Agent Bricks.
• Legacy agent builders: Oudere producten, zoals Knowledge Assistant en Supervisor Agent, worden niet langer aanbevolen voor nieuwe agenten. Bekijk legacy-agentaanbiedingen.

Aanvullende bronnen

• Agent Bricks quickstart: Bouw en deploy je eerste agent met de Agent Bricks CLI.
• Agents implementeren op Azure Databricks: Leer hoe agents worden uitgerold en aangeboden.
• Wat is observabiliteit en kwaliteit van een agent?: Traceer, evalueer en monitor je agent.
• AI op Databricks: Use cases, klanten en andere bronnen.
• Agent Bricks FAQ: Antwoorden op veelgestelde vragen over Agent Bricks.