> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Förslag och validering

## Översikt

När ElevenAgents Architect slutför en ändring lämnar den över den till dig som ett **förslag**: en gren som innehåller ändringen, tester som visar att den fungerar och ett [sammanslagningsförslag](/docs/sv/eleven-agents/operate/merge-proposals) där grenen föreslås slås samman med `main`. Den här sidan förklarar hur varje del fungerar, var du hittar den och hur ett förslag går från en konversation till live-trafik.

## Vad ett förslag är

Ett förslag bygger på den befintliga modellen för [versionshantering](/docs/sv/eleven-agents/operate/versioning):

| Del                    | Vad det är                                                                                                                                                                  |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Gren                   | En gren som Architect skapade för ändringen, så att `main` och aktiva uppringare inte påverkas medan du arbetar.                                                            |
| Utkast                 | Architects ändringar, förberedda i ditt opublicerade utkast på den grenen.                                                                                                  |
| Version                | När du publicerar utkastet blir det en ny version på grenen.                                                                                                                |
| Tester                 | Testerna som Architect skrev för ändringen, kopplade till agenten och körda mot grenen.                                                                                     |
| Sammanslagningsförslag | En begäran om att slå samman grenen med `main` (eller en annan gren som du väljer), med en beskrivning av ändringen, testerna som kördes och vad granskare bör kontrollera. |

Sammanslagningsförslaget är ett vanligt ElevenAgents-sammanslagningsförslag, av samma typ som en teammedlem öppnar manuellt. Det är inte en separat objekttyp.

Ett sammanslagningsförslag omfattar exakt en källgren och en målgren, så varje förslag innehåller en kandidatlösning. Om du vill jämföra alternativ ber du Architect att lägga varje alternativ på en egen gren. Varje gren får då ett eget förslag, och du kan dela trafiken mellan dem som ett [experiment](/docs/sv/eleven-agents/operate/experiments).

> **Note**
>
> Architect agerar som du, så ett sammanslagningsförslag som den öppnar registreras under ditt namn som författare. Inget
> fält registrerar att Architect skapade det. Nämn det i förslagsbeskrivningen om ditt team vill
> känna till det.

## Så skapas ett förslag

Architect skapar ett förslag när du ber den att rätta eller förbättra något, eller när du ger den ett misslyckat test, ett resultat från Spotlight eller ett triageärende. Hela processen, med verktygen Architect anropar i varje steg, finns i det [genomgångna exemplet](/docs/sv/eleven-agents/operate/architect/how-it-works#worked-example-improving-refund-resolutions). Kort sagt:

1. Architect undersöker, skapar en gren och förbereder ändringen i ditt utkast på den grenen.
2. Architect skriver tester och simuleringar för ändringen och kör dem i konversationen innan resultatet visas för dig.
3. Architect öppnar publiceringsdialogrutan. Du granskar diffen och väljer **Publicera**, vilket sparar ändringen som en ny version på grenen.
4. Architect öppnar ett sammanslagningsförslag till `main` och skriver beskrivningen utifrån grenens faktiska commits och testkörningar.
5. Architect erbjuder sig att skicka en liten andel av live-trafiken till grenen medan förslaget granskas. Detta kräver ditt godkännande.

Du kan avbryta vid vilket steg som helst. En gren med en publicerad version men utan sammanslagningsförslag är fortfarande användbar: du kan testa den själv eller öppna ett förslag senare.

### Validering i konversationen

Architect skriver och kör tester som en del av att bygga ändringen, inte som ett separat steg som du startar i efterhand. För en rättning är ett användbart mönster att visa att de nya testerna misslyckas utan ändringen och lyckas med den. Architect kan köra samma tester mot originalgrenen och mot utkastet som innehåller ändringen.

Architect kör inte automatiskt den här före- och efterkontrollen för varje ändring. Be om den när det är viktigt, till exempel: "Visa att den nya simuleringen misslyckas på main och lyckas på grenen, och öppna sedan ett förslag."

Ett test **godkänns** när alla villkor för att lyckas är uppfyllda. För ett LLM-test uppfyller agentens svar kriterierna för godkänt. För ett verktygsanropstest anropas det förväntade verktyget med de förväntade parametrarna. För en simulering uppfyller den simulerade konversationen sina villkor för godkänt. För att kontrollera opålitliga resultat kan du be Architect att köra tester flera gånger. Den kan upprepa varje test upp till 50 gånger och rapportera godkännandefrekvensen.

Se [Tester](/docs/sv/eleven-agents/customization/agent-testing) för hur varje testtyp definieras.

## Var du hittar förslag

Öppna agenten och gå sedan till **Versionshantering** > **Förslag**. Listan kan filtreras efter status, författare (**Skapad av**) och granskare (**Väntar på granskning från**, **Granskad av**). Ett förslag som Architect öppnade i din konversation visas med dig som författare.

Architect returnerar också en länk till förslaget i konversationen så snart den har skapat det.

![Förslagslista på sidan Grenar](/docs/_fern-img/bfdb23ad1edb31c89c2ff2a137fa3028bf3f9fbcf31e236de142e207b5d54cd0.webp)

## Ett förslags delar

Ett förslags sida visar käll- och målgrenarna, dess status, om det kan slås samman och hur långt källgrenen ligger efter eller före målet. Den har följande flikar:

#### Översikt

Beskrivningen, en aktivitetstidslinje med commits på källgrenen, granskningar och kommentarer samt ett kommentarsfält. Sidofältet visar granskare, rekommenderade granskare och eventuella länkade triageärenden.

En beskrivning som Architect skriver har alltid tre avsnitt: **Sammanfattning** (varje betydande ändring och varför), **Testning** (vilka tester som kördes och deras resultat, eller ett meddelande om att inga kördes) och **Så granskar du** (vad du ska fokusera på och ett test att köra eller en konversation att prova).

![Fliken Översikt för ett sammanslagningsförslag](/docs/_fern-img/569eccd1750f90cd5ec8121411e8effd3a38e924e0f03f06f6216a9fcc160e08.webp)

#### Ändringar

Konfigurationsdiffen: hur målgrenen kommer att se ut efter sammanslagningen jämfört med sitt nuvarande tillstånd. Om båda grenarna har ändrat samma fält visar vyn **Konflikter** varje konflikt och vilken sida som vinner.

När förslaget har slagits samman visar den här fliken målgrenen före och efter sammanslagningen.

![Fliken Ändringar för ett sammanslagningsförslag](/docs/_fern-img/cd06c0f93240d7c973101b896599542290437a6dcbfa6d288a25db0c1bfcd566.webp)

#### Testkörningar

Godkännandefrekvensen och testkörningshistoriken för källgrenen, inklusive körningarna Architect startade i konversationen. Växla till målgrenen för att jämföra dess godkännandefrekvens. Välj **Kör tester** för att köra alla kopplade tester på valfri gren igen, eventuellt flera gånger vardera.

Testkörningar är kopplade till grenen, inte till förslaget. Sammanslagning kräver inte att tester godkänns. Granskarna avgör utifrån vad fliken visar.

![Fliken Testkörningar för ett sammanslagningsförslag](/docs/_fern-img/58e28b31cb3408fe5bf8e9193f4a4edb5e716e6023c56f29d5a4f924c70a0f7a.webp)

#### Konversationer

Varje konversation som kördes på källgrenen, inklusive live-trafik som skickades dit genom en trafikdelning. Välj en konversation för att öppna dess transkription. När en gren har en gradvis utrullning är det här du ser hur verkliga uppringare använder ändringen.

![Fliken Konversationer för ett sammanslagningsförslag](/docs/_fern-img/f6345ff5beaee9a22732c7322995a7e889245cda7901682ab390790ef3849690.webp)

## Granskning och sammanslagning

### Statusar

Ett sammanslagningsförslag har någon av följande statusar:

| Status      | Betydelse                                                                                                                         |
| ----------- | --------------------------------------------------------------------------------------------------------------------------------- |
| Öppen       | Väntar på granskning eller sammanslagning.                                                                                        |
| Sammanfogad | Grenen slogs samman med målet.                                                                                                    |
| Stängd      | Återkallad av författaren, avvisad av någon annan eller stängd eftersom grenen arkiverades. Stängda förslag kan inte öppnas igen. |

Medan ett förslag är öppet är varje granskares senaste granskning antingen **Godkänd** eller **Ändringar begärda**. Det finns inga separata statusar för "testad" eller "redo för granskning". Testresultat visas i stället på fliken **Testkörningar**.

Granskningar och kommentarer visas på aktivitetstidslinjen på fliken **Översikt**, tillsammans med varje ny version som sparas på källgrenen.

![Aktivitetstidslinje för ett sammanslagningsförslag](/docs/_fern-img/522012341d0089ff418032a34bae6653d2b883934b64a0b6a12de887646b2f5f.webp)

### Vem kan godkänna och slå samman

* Alla med redigeringsåtkomst till agenten kan granska ett förslag, utom dess författare. Eftersom Architect agerar som du kan du inte godkänna ett förslag som Architect öppnade i din konversation. Det måste en teammedlem göra.
* Ett förslag kan slås samman när det har minst ett godkännande från någon annan än författaren och ingen granskares senaste granskning är **Ändringar begärda**. Workspace-administratörer kan slå samman utan ett godkännande.
* Sammanslagning med en [skyddad gren](/docs/sv/eleven-agents/operate/versioning) kräver administratörsbehörighet eller ett godkännande från en administratör.

Architect kan inte godkänna, kommentera, slå samman eller stänga ett sammanslagningsförslag. Dessa steg utförs alltid av människor. Se [Sammanslagningsförslag](/docs/sv/eleven-agents/operate/merge-proposals) för de fullständiga granskningsreglerna.

> **Warning**
>
> Architect kan slå samman en gren direkt, utan ett förslag, när du ber den om det och din roll tillåter
> sammanslagningen. I läget **Godkännande krävs** frågar den först. I läget **Godkänn automatiskt** gör den inte det. Använd
> grenskydd på `main` om varje ändring måste gå via ett granskat förslag.

### Vad som händer vid sammanslagning

Det finns inget separat publiceringssteg efter en sammanslagning. Sammanslagning skapar en ny version på målgrenen, och den versionen hanterar live-trafik direkt för den trafikandel som målet tar emot. När målet är `main` och ingen trafikdelning har angetts innebär det alla uppringare.

Sammanslagning:

* Flyttar den live-trafikandel som källgrenen hade till målet.
* Arkiverar källgrenen som standard.
* Stänger alla andra öppna förslag från samma gren.
* Löser det länkade triageärendet, om det finns något.

## Gradvis utrullning

Innan ett förslag har slagits samman kan du skicka en andel av live-trafiken till dess gren så att verkliga uppringare använder ändringen.

#### Starta delningen

Be till exempel Architect: "Skicka 5 % av trafiken till den här grenen." Architect berättar om den fullständiga
resulterande fördelningen, inklusive `main`s andel, och ber om godkännande innan den tillämpar den. Du kan
också ange den själv: välj **Distribuera** på grenen i **Versionshantering** > **Grenar**.

#### Följ resultaten

Öppna förslagets flik **Konversationer** för att läsa konversationer på grenen, eller be Architect
jämföra grenens resultat med `main`s.

#### Främja eller återställ

För att främja ändringen slår du samman förslaget. Grenens trafikandel flyttas med den till `main`. För att
återställa ber du Architect att ange grenens andel till 0 %, eller redigerar distributionen själv. Live-
trafiken återgår till `main` direkt.

Trafikandelar måste alltid bli 100 % totalt, och routningen är deterministisk per konversation. Att ändra andelen för en skyddad gren, inklusive att ta trafik från en skyddad `main`, kräver en administratör. Se [Trafikdistribution](/docs/sv/eleven-agents/operate/versioning#traffic-deployment).

## Proaktiva förslag

> **Note**
>
> Architect skapar förslag när du ber den om det, eller när du ger den ett misslyckat test, ett resultat från Spotlight,
> en avisering eller ett triageärende. Den söker ännu inte igenom dina agenter enligt ett schema eller öppnar
> förslag på egen hand.

Den proaktiva processen i dag är [Spotlight](/docs/sv/eleven-agents/dashboard/spotlight) följt av en överlämning. Spotlight övervakar kontinuerligt din agents konversationer. Den ger en veckosammanfattning med föreslagna undersökningar, skapar realtidsaviseringar och rekommenderar konfigurationsändringar. Så här gör du ett resultat från Spotlight till ett förslag:

#### Öppna Spotlight

Öppna agenten. Dess översiktssida är Spotlight.

#### Välj ett resultat

Öppna veckosammanfattningen och granska **Föreslagna nästa steg**, eller öppna en realtidsavisering.

#### Överlämna det till ElevenAgents Architect

Välj **Öppna i Architect** på ett förslag, **Analysera med Architect** i sammanfattningen eller
**Undersök med Architect** för en avisering. Architect tar emot resultatet och instrueras att
verifiera det mot verkliga konversationer och identifiera vilken gren som påverkas innan den
föreslår en ändring.

#### Be om ett förslag

Granska Architects resultat. Om du håller med om grundorsaken ber du den att rätta problemet på en
gren, testa rättningen och öppna ett förslag.

Triageärenden fungerar på samma sätt. Din aktiva agent kan [markera problem för granskning](/docs/sv/eleven-agents/customization/tools/system-tools/flag-issue-for-review) under konversationer, och **Diskutera med Architect** i ett ärende startar en undersökning av det.

Schemalagda automatiseringar, med rapporter som levereras till en Architect-inkorg, är under utveckling. Fliken **Inkorg** på Architect-sidan är en platshållare för dem.