2026-10-05, 15:48
  #73
Medlem
Mr.RedHats avatar
Claude mods — Del 1

Kod:
[noparse
Detta inlägg är skrivet med hjälp av ChatGPT som fått ta del av min interna dokumentation, och därefter reducerat, obfuscerat och generaliserat innehållet till något gemene man kan använda

Claude har släppt ny uppdatering!
Anthropic har precis byggt ut Claude Code med något de kallar Mods. Blogginlägget:
? Getting started with Claude mods
? Dokumentationen[/noparse]

Det här är, åtminstone för mig, betydligt mer intressant än ännu en vanlig modelluppdatering.

Mods innebär i praktiken att man kan bygga vidare på själva Claude Code-klienten. Inte bara ge Claude fler instruktioner eller MCP-verktyg, utan lägga deterministisk programlogik runt agenten: paneler, timers, events, slashkommandon, notifieringar och integrationer som kan leva utanför modellens vanliga turn-loop.

Claude Code 2.1.287 eller senare krävs, och Mods är påslagna som standard. Och det förändrar ganska mycket hur jag tänker kring långlivade agenter.

Vad är en mod?
Det är egentligen missvisande att tänka på dem som vanliga "plugins". En mod är Javascript/Typescript som körs inne i Claude Codes eventmotor. Den kan bland annat:
  • lägga till egna slashkommandon,
  • rita paneler, statusrader, dialogrutor och inputfält,
  • köra timers,
  • läsa och skriva filer,
  • starta processer,
  • göra HTTP-anrop,
  • anropa MCP-servrar,
  • skicka meddelanden mellan Claude-sessioner,
  • reagera på tool calls,
  • ändra eller stoppa tool calls,
  • skicka nytt innehåll till modellen när något händer.

Det är alltså i praktiken ett API för att bygga vidare på själva Claude Code. Ett enkelt exempel skulle kunna vara en mod som kontrollerar GitHub eller Forgejo och visar:

Kod:
Pull request #42

CI:     passed
Review: waiting
Branch: feature/foo

i en liten panel.

Ingen modell behöver köras för detta. Om något faktiskt händer kan modden därefter starta en Claude-turn. Det är en viktig distinktion.

I dag använder många Claude ungefär så här:
Kod:
något händer
↓
Claude läser det
↓
Claude resonerar
↓
Claude uppdaterar state

Med mods kan mycket i stället bli:

Kod:
något händer
↓
programkod uppdaterar state/UI
↓
Claude väcks bara om resonemang behövs

Det tror jag är en rätt stor grej för långlivade agentmiljöer.

Mods är dock INTE sandboxade

Det här är den viktiga detaljen. En mod är inte en säker sandbox.

API:t är byggt så att moddens egna anrop kan deklareras och granskas, exempelvis filaccess, processkörning, HTTP, MCP och interaktion med sessionen. Det gör att man kan få en hygglig bild av vad modden vill göra.

Men om en mod får starta en vanlig process så kör den processen med samma Unix-rättigheter som användaren som kör Claude Code.

Att få:
Kod:
process.run

bör därför i praktiken läsas ungefär som:

Kod:
kan köra godtycklig kod med mina användarrättigheter

Det är alltså inget magiskt säkerhetslager.
Mods är kraftfulla just därför att de kör nära själva Claude Code-klienten.

Det intressanta är granskningsmodellen
Claude Code har:

Kod:
claude plugin validate

för plugins/mods.

Det gör att man kan analysera en mod innan den körs och se vilka hooks och capabilities den använder. Det öppnar för något jag tycker är betydligt mer användbart än vanlig kodreview: capability review.

Anta att version 1 använder:
Kod:
fs.read
ui.status

och nästa version plötsligt använder:

Kod:
fs.read
ui.status
process.run
tool.check

Det är inte bara "+37 -12 lines". Det är en faktisk privilegieökning.

Man skulle exempelvis kunna presentera detta i CI:
Kod:
Version 1 → Version 2

ADDED:
process.run
tool.check

UNCHANGED:
ui.status
fs.read

Riskklass:
UI-only → process execution

Det tycker jag är ett mycket vettigare sätt att granska agentverktyg.

Låt agenten skriva sina egna uppgraderingar, men aldrig aktivera dem själv

Det här är modellen jag själv tycker verkar mest lovande.
Jag tycker inte att man skall försöka hindra Claude från att skriva plugins eller mods åt sig själv. Det vore nästan att kasta bort hela poängen. Om agenten efter några veckor säger:

Kod:
Jag gör väldigt ofta X.

Jag skulle kunna skriva en mod som automatiserar X
och sparar många onödiga turns.

så är mitt spontana svar: Fine. Skriv den.
Men:
Kod:
kan skriva ≠ kan installera

Jag tänker mig ungefär:

Kod:
Claude föreslår mod ↓ branch / pull request ↓ plugin validate ↓ automatiska tester ↓ människa eller separat reviewer granskar ↓ merge ↓ privilegierad installation ↓ modden laddas nästa gång Claude startar

Claude får alltså gärna modifiera sin egen källkod. Det viktiga är att Claude-processen inte samtidigt har rätt att aktivera förändringen.

Det är en mycket bättre säkerhetsgräns än instruktionen:
Kod:
"du får inte modifiera dig själv"

För det är bara en promptregel. En filkatalog som agentens användare inte kan skriva till är däremot en riktig teknisk gräns.

Claude Code har managed settings för detta, bland annat möjlighet att kräva att bara administrativt godkända mods får laddas och att stänga sideload-vägar. Det är först då "self-upgrading agent" börjar bli intressant på riktigt. Agenten kan föreslå sin egen utveckling, men godkännandet ligger utanför agentens kontroll.

En capability per mod

En annan princip jag tycker verkar vettig:

Kod:
En mod = en tydlig capability

Inte någon:

Kod:
super-agent-helper.ts

som efter ett år kan SSH, secrets, deployment, task boards, mail, API-anrop och agentkommunikation.

Hellre:
Kod:
repo-notifications
task-board
deploy-status
agent-messaging
review-helper

var för sig.

Då går varje capability att aktivera, stänga av, granska och versionshantera separat. Det minskar också risken att agentmiljön långsamt muterar till någon sorts "megabot" där ingen längre riktigt vet varför den har alla sina rättigheter.

Ett konkret användningsfall: events utan att slösa tokens

Anta att jag vill att Claude skall reagera när någon kommenterar på ett issue.
Den dumma varianten är:
Kod:
Claude:
"kolla om något hänt"

30 minuter senare:

"kolla igen"

30 minuter senare:

"kolla igen"

Det är modellturns för ett problem som cron löste för ett halvsekel sedan.

Med vanlig programkod:
Kod:
timer
↓
API-anrop
↓
ingenting nytt
↓
ingen Claude-turn

Men:

Kod:
timer
↓
ny kommentar
↓
visa notification
↓
skicka event till sessionen
↓
Claude vaknar

Ännu bättre är förstås webhook/eventdrivet:

Kod:
Forge
↓
event
↓
Claude-miljön

så att polling helt försvinner.

Poängen är densamma:

Claude skall inte användas som cron, databas eller message queue.

Använd modellen där resonemang faktiskt behövs.

Fortsätter i nästa inlägg med task boards, secrets, agent-till-agent och hur jag tycker samma modell går att applicera på shy, se tidigare inlägg *klick*

Se del 2 *klick*
__________________
Senast redigerad av Chantre 2026-10-08 kl. 19:50. Anledning: Korrigerat länkar
Citera
2026-10-05, 16:15
  #74
Medlem
Mr.RedHats avatar
Claude mods — del 2

Se del 1 här *klick*


Task boards är ett annat uppenbart område
Jag har tidigare experimenterat med att låta själva agenten hålla väldigt mycket projektstate. Det fungerar, men jag tycker allt mer att det är fel abstraktionsnivå.

Saker som:
Kod:
todo
doing
review
blocked
done

är inte resonemang. Det är state. State bör ligga i vanlig deterministisk programvara.

Exempel:

Kod:
GitHub/Forgejo issues
↓
liten controller
↓
Claude-panel

Då kan Claude se:

Kod:
TODO      3
DOING     2
REVIEW    1
BLOCKED   1

utan att modellen behöver hålla detta i sitt context eller återberätta projektläget för sig själv. Claude skall resonera om vad som bör göras. Claude behöver inte vara databasen som kommer ihåg att issue #17 har status "review".

Det här har blivit en ganska generell designprincip för mig:

Kod:
operational state hör hemma i programvara,
inte i modellens context.

Secrets är däremot ett område där jag skulle vara försiktig

Det går i teorin att bygga en mod som visar ett inputfält:

Kod:
API token:
[_____________________]

utan att texten behöver skickas till modellen. Det är användbart. Men det betyder inte automatiskt att man har byggt en säker secret manager.

Om man:

Kod:
skriver secret
→ krypterar
→ chmod 600

så har man kanske skyddat hemligheten mot andra Unix-användare och mot att den råkar hamna i transcriptet. Man har däremot inte nödvändigtvis skyddat den mot annan kod som kör under samma användare.

Därför tror jag mer på:
Kod:
Claude ↓ "jag behöver göra X" ↓ separat broker ↓ operatören godkänner ↓ brokern använder secretet ↓ Claude får resultatet

Alltså hellre:
Kod:
deploy_this_build()

än:

Kod:
give_me_PRODUCTION_API_TOKEN()

En mod är bra för UI och orchestration. Den skall inte automatiskt betraktas som en security boundary bara för att secretet aldrig syntes i chatten.

Agent-till-agent (A2A) blir också intressant

När man börjar ha flera agenter finns ett annat problem: hur de skall kommunicera utan att allt blir en enorm gemensam konversation. Jag tycker det är vettigt att skilja på:

Kod:
MESSAGE PLANE

och:

Kod:
ARTIFACT PLANE

Små meddelanden kan gå direkt:

Kod:
"Jag har ett patchförslag till foo.c"

Men själva patchen behöver inte skickas som 4 000 rader text mellan modeller. Lägg den i ett litet git-repo eller gist och skicka:

Kod:
kind: patch-proposal
artifact: <git-url>
base: <commit>
sha256: ...

Mottagaren hämtar den därefter i en disposable worktree:

Kod:
fetch
→ verify base
→ apply
→ test
→ inspect
→ kasta worktree

Det tycker jag är betydligt bättre än:

Kod:
apply
→ hoppas
→ undo

Git är redan väldigt bra på att transportera kod.

Det finns sällan anledning att bygga ett eget sämre diff-protokoll ovanpå LLM-chatten.

Det här knyter ganska snyggt an till shy
Jag skrev tidigare om mitt lilla shell-projekt shy:
https://github.com/alfred-intelligence/shy

Grundidén där är att bryta ut små shell-funktioner, scripts, alias och plugins till återanvändbara komponenter i stället för att låta allt växa ihop i en enorm .bashrc. Ju mer jag arbetar med agentmiljöer desto mer tror jag att samma princip gäller där.

I stället för:
Kod:
en gigantisk agentmiljö
med hundratals specialregler

vill jag hellre ha:

Kod:
liten kärna
+
små deklarerade capabilities
+
tydliga integrationsgränser

Jag funderar därför på att dra shy ännu längre åt det hållet.

Exempelvis:

Kod:
shy-mod

för något som endast kan arbeta inne i en sandbox,

och:

Kod:
shy-connector

för något som uttryckligen får kommunicera med omvärlden.

Exempel:

Kod:
SHY-MOD

- formatter
- parser
- lokal filbearbetning
- markdownrendering

SHY-CONNECTOR

- GitHub
- Forgejo
- SSH
- Cloudflare
- Proxmox
  

Varje komponent skulle då ha ett manifest som beskriver sina capabilities.

Exempelvis:

Kod:
[capabilities]

network = false
filesystem = ["workspace"]
binaries = ["git"]
hosts = [""]
secrets = [""]

eller:

Kod:
[capabilities]

network = true
hosts = ["build-server"]
secrets = ["deploy-token"]
exec_remote = true

Det viktiga är dock att manifestet inte bara blir dokumentation. Om manifestet säger:
Kod:
network = false

men processen ändå kan öppna vilken socket den vill så är manifestet bara säkerhetsteater. För att detta skall vara intressant måste deklarationen faktiskt kunna enforceas.

På Linux finns rätt många byggblock för detta:
  • namespaces,
  • bubblewrap,
  • Landlock,
  • seccomp,
  • cgroups,
  • network namespaces,
  • separata SSH-brokers,
  • separata secret-brokers.

Där börjar jag se en ganska intressant gemensam modell:

Kod:
Claude mod:
calls:

- fs.read
- ui.status

shy component:
capabilities:
filesystem:
- workspace
network: false

Två helt olika program, men ungefär samma granskningsidé:

Vad får den här komponenten faktiskt göra?
Ett trivialt exempel på varför detta spelar roll

Säg att man har:
Kod:
alias pct-update='for PCT in $(pct-local); do pct exec $PCT -- apt-get update && apt-get upgrade -y ; done'

Det ser kanske rätt ut vid snabb läsning.

Men:
Kod:
&&

tolkas av hostens shell.
Så i praktiken kan resultatet bli:

Kod:
pct exec $PCT -- apt-get update

och därefter:

Kod:
apt-get upgrade -y

på själva hosten.

Korrekt variant behöver hålla ihop det kommando som skall köras i containern:

Kod:
pct exec "$PCT" -- sh -c 'apt-get update && apt-get upgrade -y'

Det här är exakt den typ av sak jag vill generalisera bort.

I stället för tio handskrivna loopar bygger man:

Kod:
pct-each <command>

en gång, skriver tester för den och återanvänder den.

Det är ungefär samma filosofi som jag tror blir viktig med AI-agenter: Bygg inte hundra prompts som säger åt agenten hur den skall undvika samma klass av misstag. Bygg en deterministisk komponent som gör operationen rätt.

Lite pushback mot hela mod-hypen

Jag tycker alltså Mods är väldigt lovande. Men jag tror också det är lätt att göra misstaget:
Kod:
"Claude kan nu köra mer kod,
alltså skall allt bli en Claude-mod."

Nej. Jag skulle ungefär dela upp det så här:

Bra som mod:
  • UI,
  • statuspaneler,
  • notifieringar,
  • timers,
  • eventhantering,
  • task-board projection,
  • interaktion med Claude-sessionen,
  • små lokala automatiseringar.

Bättre som extern tjänst:
  • secret management,
  • root-operationer,
  • privilegierad SSH,
  • deploy brokers,
  • permanent job queue,
  • policy enforcement,
  • auditlogg som agenten inte själv kan ändra.

Bättre som MCP:
  • väl avgränsade tools som modellen uttryckligen skall resonera kring.

Och ibland är lösningen fortfarande bara:

Kod:
bashlet.sh

Det är lätt att glömma när allt nytt får ett AI-prefix.

Min preliminära modell

Jag börjar allt mer tänka mig agentmiljön ungefär så här:
Kod:
Claude
│
│ reasoning
▼
Claude Code
│
┌────────┼────────┐
│        │        │
Mods      MCP     Skills
│        │
│        └──── model tools
│
└──── UI / events / local orchestration

            │
            ▼
    privileged boundary
            │
   ┌────────┼─────────┐
   │        │         │
secrets    SSH      deploy
broker    broker     runner
   │        │         │
   └────────┴─────────┘
            │
            ▼
         hosts

Det viktiga är egentligen den horisontella gränsen. Claude och dess mods får gärna vara väldigt smarta. Men de behöver inte därför få vara root.

Det mest intressanta är kanske inte Mods i sig
Det mest intressanta för mig är att Claude Code börjar gå från:

Kod:
"AI som kör terminalkommandon"

till:

Kod:
"programmerbar agent-runtime"

Det är en ganska stor konceptuell skillnad.
— MCP gav modellen externa verktyg.
— Skills gav den återanvändbar kunskap och arbetsmetodik.
— Subagents gav den möjlighet att dela upp arbete.
— Mods börjar i stället ge oss möjlighet att programmera miljön runt modellen.

Och där tror jag den verkligt stora vinsten finns. Ju mer deterministiskt arbete man kan flytta bort från själva modellen, desto mer kan modellen användas till det den faktiskt är bra på:
Kod:
förstå
resonera
planera
granska
välja

och desto mindre behöver den användas till:

Kod:
polling
timers
state
routing
formattering
bookkeeping

Det är ungefär den riktning jag själv tänker experimentera vidare med nu. Samtidigt som jag får en anledning att ta bort root-privilegier från min AI, som fått en hel dedikerad VM att leka i. Vilket gått bra. Men det är dåligt säkerhetstänk.

Summa sumarum: Shy gick att användas för att ta sig förbi spärrar. Nu ska det istället användas för att tillsammans med Claudes config-fil enforca dem. Det är mycket bättre arkitektur än när spärrarna träffade usern snarare än modellen. Så nu vänder vi på steken och ser om nästan det motsatta fungerar bättre, där vi omsätter trivialla regler till programkod och pipeline på CD-flöde för triviala ändringar som inte ändrar capabilities och därmed kan köras i en patch utan en enda mänsklig grind med bibehållen regel om förbud mot självmodifiering, då den istället gäller vilka capabilities som träffas, inte huruvida den får göra ändringar eller ej.
__________________
Senast redigerad av Mr.RedHat 2026-10-05 kl. 16:30.
Citera
  • 6
  • 7

Skapa ett konto eller logga in för att kommentera

Du måste vara medlem för att kunna kommentera

Skapa ett konto

Det är enkelt att registrera ett nytt konto

Bli medlem

Logga in

Har du redan ett konto? Logga in här

Logga in