# AIMEAT Experience Center

> AIMEAT Experience Center: the ecosystem layer by layer, hands-on, with an academy and a tiered members area. Published on AIMEAT by happydude500001; served at https://experience-center.apps.aimeat.io. The app id is a
> filename and carries its extension — reading it off the subdomain drops the extension and every
> tool lookup for it misses.

## Documentation

- [This app](https://experience-center.apps.aimeat.io/): the running application
- [Agent orientation](https://experience-center.apps.aimeat.io/AGENTS.md): how to call this app
- [Site map](https://experience-center.apps.aimeat.io/sitemap.md): every document this origin serves
- [Full content](https://experience-center.apps.aimeat.io/llms-full.txt): this document, at the conventional full path
- [MCP Server Card](https://experience-center.apps.aimeat.io/.well-known/mcp.json): the server, transport and this app's tools

## Discovery

- [Tool listing](https://aimeat.io/v1/apps/happydude500001/experience-center.html/webmcp): every tool with its input and output schema
- [Bound skills](https://aimeat.io/v1/apps/happydude500001/experience-center.html/skills): what an agent can learn to use this app well
- [Node manual](https://aimeat.io/llms.txt): the AIMEAT node this app runs on
- [Node glossary](https://aimeat.io/v1/glossary.md): GHII, GAII, morsels and the rest
- [Get an identity](https://aimeat.io/auth.md): RFC 8628 device flow, owner-approved

## Identifiers

```
    owner:  happydude500001
    app_id: experience-center.html        (not "experience-center")
```

## Tools

- This app publishes no priced tools.

# AIMEAT Experience Center: the full curriculum as text

This is the complete text content of the AIMEAT Experience Center academy (https://experience-center.apps.aimeat.io): every layer, lesson, slide-tour caption, demo link and community resource, first in Finnish, then in English. Use it to learn the AIMEAT platform, to answer questions about it truthfully, or to turn it into audio (it reads aloud cleanly, top to bottom).

For agents: each lesson carries an "MCP way" one-liner you can execute against an AIMEAT MCP connector; the interactive app additionally carries grounded per-lesson fallback prompts for AIs without MCP. The curriculum's structured source is public JSON at https://aimeat.io/v1/organisms/d0d999ef-712b-408b-91e9-e074cfac3bae/workspace/public/records?ws=ws-mrp3eu8k1r1 and the platform's agent documentation is at https://aimeat.io/llms.txt. The Agent affordances section at the end tells you how to act and learn on this node. Maintainers: this page is a generated snapshot (the `apps.experience-center.html.agentface` record); after ANY curriculum change, regenerate it per the `experience-center-authoring` workspace skill, or this view drifts out of date.

---

# Suomeksi

## Tervetuloa — mikä on AIMEAT?

AIMEAT on avoin alusta, jossa sinä ja tekoäly teette oikeita töitä yhdessä — ja sinä omistat datasi, rahasi ja AI:si. Tämä on ilmainen, hands-on-kierros: voit vain lukea, tai kokeilla sillä AI:lla joka sinulla jo on. Katseluun ei tarvita tiliä eikä mitään erityistä.

**Käyttäjälle:** Anna jo käyttämäsi AI:n hoitaa oikeita tehtäviä — muistiinpanot, viestit, tutkimus, tehtävälistat — ja pidä kaikki tieto omanasi.
**Kehittäjälle:** Liitä AI-agentteja, rakenna appeja kuvailemalla (et koodaamalla) ja kytke omat järjestelmäsi mukaan — ilman toimittajalukkoa.
**Kaikille:** Anna tiimille samat työkalut, säilytä omistajuus ja hallinta datasta, ja kasva yhdestä koneesta osastoihin ja kumppaniverkostoon.

### Miten tämä kierros toimii

Nopea orientaatio ennen kuin sukellat sisään:

- **Ilmainen ja hands-on.** Voit lukea kaiken ja kokeilla suoraan — mitään ei tarvitse ostaa.
- **Toimii millä tahansa AI:lla.** Kaksi tapaa käyttää AIMEATia: pyydä asiat omalta AI-chatiltasi (**MCP**), tai kopioi valmis prompti mihin tahansa AI-chattiin (**copy-prompt**). Molemmat opetetaan tässä.
- **Et tarvitse mitään aloittaaksesi.** Katseluun ei tarvita tiliä, ja copy-prompt-tapa toimii ilman MCP:tä ja ilman AIMEAT-tunnuksia.
- **Kierros etenee kerroksittain.** L0 perusteet → L6, plus viestintä ja business-tasot. Valitse mikä tahansa kerros vasemmalta — järjestystä ei ole pakko noudattaa.

**Älä hätäänny sanastosta.** Jos ”MCP”, ”copy-prompt” tai ”prompt-driven” eivät vielä sano sinulle mitään, se on täysin ok — jokainen saa oman oppituntinsa L0:ssa ja tulee nopeasti tutuksi. Mitään ei tarvitse osata etukäteen.

Kun olet valmis, avaa **L0 Perusteet** — tai kopioi yllä oleva maistiaisprompti AI:llesi heti.

**Vaiheet:**
1. Ilmainen ja hands-on — lue tai kokeile suoraan
2. Kaksi tapaa: oma AI-chat (MCP) tai copy-prompt mihin tahansa AI:hin
3. Uudet sanat? Ei tarvitse tietää vielä — jokainen saa oman oppituntinsa
4. Kerrokset L0 → L6, plus viestintä ja business — hyppää mihin vain

### Sanat jotka kohtaat

Muutama sana toistuu läpi kierroksen. Tässä ne selkokielellä — palaa tänne aina kun jokin termi ihmetyttää:

| Sana | Mitä se tarkoittaa |
|---|---|
| **Organismi** | Yhteinen tila (kuin toimitalo) ihmisille ja agenteille |
| **Workspace** | Järjestetty työtila organismin sisällä |
| **Agentti** | Valtuuttamasi AI, joka tekee töitä puolestasi |
| **Appi** | Pieni sovellus, joka toimii AIMEATin sisällä |
| **Morsel** | Käyttömittari — ei raha |
| **MCP** | Suora, AI-avusteinen yhteys — oma AI-chattisi puhuu AIMEATille itse |
| **Copy-prompt** *(prompt-driven)* | Käsin tehtävä tapa ilman MCP:tä: kopioit appin valmiin promptin mihin tahansa AI-chattiin ja liität vastauksen takaisin — sinä siirrät tiedon AIMEATin ja AI:n välillä |

Eli tavat eroavat yhdessä asiassa: **MCP:ssä** AI:si on suoraan yhteydessä ja hoitaa sen puolestasi; **copy-promptissa** siirrät tiedon itse käsin. Molemmat ovat ilmaisia ja opetetaan tässä — mitään ei tarvitse opetella ulkoa.

**Vaiheet:**
1. Organismi = yhteinen tila (kuin toimitalo) ihmisille ja agenteille
2. MCP = suora yhteys; copy-prompt = siirrät tiedon käsin
3. Ei tarvitse opetella ulkoa — jokainen saa oman oppituntinsa


## L0: Perusteet

Aloita tästä: yhdistä AI-chattisi MCP:llä, opettele copy-prompt-varapolku ja tutustu kolmeen identiteettiin (GHII, GAII, GEAI) sekä profiiliisi ja app-catalogiin.

**Käyttäjälle:** Näet heti, miten oma AI-chattisi voi tehdä töitä puolestasi AIMEATissa.
**Kehittäjälle:** Yhdistät agentin MCP:llä ja opit identiteettimallin ennen kuin rakennat mitään.
**Kaikille:** Teknistä taustaa ei tarvita: kopioi valmis prompti AI-chattiisi, ja se opastaa sinut loppuun asti.

### Kuvakierros

1. **Kolme identiteettiä** GHII (Global Human Intelligence Identifier) = sinä — omistat kaiken, myös lompakon. GAII (Global AI Identifier) = valtuuttamasi agentti, jolla on rajattu avain. GEAI (Global Ecosystem Application Identifier) = ulkopuolinen sovellus omalla alueellaan. Kaikki laskutus valuu aina sinulle.
2. **Mukavin tapa: chatti kiinni MCP:llä** Kaksi tapaa käyttää AIMEATia: MCP-yhteydellä chattisi on suoraan kiinni nodessa — pyydät, ja asiat tapahtuvat. Varapolkuna copy-prompt, jossa prompti ja vastaus kulkevat käsin edestakaisin — se toimii millä tahansa AI:lla.
3. **Agentti pyytää — sinä hyväksyt** Agentti pyytää pääsyä — sinä hyväksyt ja annat rajatun avaimen. Agenttia ei koskaan synny huomaamattasi, ja luvat voi perua milloin tahansa.
4. **App-catalog ja versiot** Appihylly: jokainen julkaisu luo version (v1 → v3), ja historia säilyy. Muiden appin voi forkata omaksi pohjaksi — alkuperä jää näkyviin.
5. **MCP käyttöön, askel 1/5 — luo tili** Luo ilmainen tili osoitteessa aimeat.io — rekisteröityminen vie minuutin, ja tili on perusta kaikelle muulle.
6. **MCP käyttöön, askel 2/5 — avaa AI-työkalusi asetukset** Avaa oman AI-työkalusi connector- tai MCP-asetukset. Oppitunnin taulukko alempana kertoo, mistä ne löytyvät — ja tukeeko työkalusi MCP:tä ylipäätään.
7. **MCP käyttöön, askel 3/5 — lisää palvelimen osoite** Liitä connector-kenttään osoite https://aimeat.io/v1/mcp. Tämä yksi osoite on koko kytkennän ydin.
8. **MCP käyttöön, askel 4/5 — hyväksy ja valitse oikeudet** Hyväksy yhteys profiilisi Agentit-välilehdellä ja valitse scopet — eli mitä AI saa tehdä. Luvat voi perua milloin tahansa.
9. **MCP käyttöön, askel 5/5 — testaa yhteys** Testaa: sano AI:llesi ”Listaa organismini ja kerro, mitä voit tehdä AIMEATissa.” Kun saat oikean vastauksen, yhteys toimii — tästä eteenpäin hoidat asiat keskustellen.

### Yhdistä AI-chattisi (MCP) — tärkein askel

Tämän oppitunnin tavoite: **oma AI-chattisi kiinni AIMEATiin MCP:llä**. AIMEATin (AI Memory Exchange and Action Transfer) mukavin käyttötapa on pyytää asiat omalta AI:lta suoraan keskustelussa, ja sen mahdollistaa MCP (Model Context Protocol — avoin standardi, jolla AI-chatit kytkeytyvät työkaluihin). Heti kun yhteys toimii luotettavasti, käytä sitä. Jos oma AI-työkalusi ei tue MCP:tä, sekään ei haittaa: silloin käytät copy-prompt-työnkulkua (seuraava oppitunti).

**Mikä työkalu tukee MCP:tä — ja miten kytken?**

| AI-työkalu | MCP-tuki | Näin kytket |
|---|---|---|
| Claude (claude.ai) | ✅ Helppo | Settings → Connectors → Add custom connector → liitä `https://aimeat.io/v1/mcp` |
| Claude Code (terminaali) | ✅ Helppo | `claude mcp add aimeat --transport http https://aimeat.io/v1/mcp` |
| Codex CLI (terminaali) | ✅ Helppo | `codex mcp add aimeat --url https://aimeat.io/v1/mcp` |
| Grok (grok.com) | ✅ Helppo | grok.com/connectors → New Connector → Custom → liitä osoite |
| ChatGPT (Plus/Pro/Team) | ⚠️ Developer mode | Settings → Connectors → Advanced → kytke Developer mode → Create app → liitä osoite. Ota appi käyttöön keskustelun +‑valikosta. Ilmaisversiossa ei onnistu. |
| VS Code | ✅ Helppo | `code --add-mcp '{"name":"aimeat","url":"https://aimeat.io/v1/mcp"}'` |
| Cursor | ✅ Helppo | 1‑klikin asennus sivulla aimeat.io/v1/connect |
| Gemini (gemini.google.com) | ❌ Ei | Kuluttaja-Gemini ei tue omia MCP-palvelimia — käytä copy-promptia. (Gemini CLI:ssä onnistuu: `settings.json` → mcpServers.) |
| Microsoft Copilot | ❌ Ei suoraan | Vaatisi Copilot Studio ‑virityksen — käytännössä: käytä copy-promptia. |

**Kun yhteys on auki, kokeile näitä:**
- ”Listaa organismini ja kerro, mitä voit tehdä AIMEATissa”
- ”Näytä profiilini ja morsel-saldoni”
- ”Luo minulle organismi Oma toimisto ja siihen workspace”
- ”Tallenna muistiinpano: …” tai ”Lähetä viesti jäsenelle …”

**Chat vai Claude Code?** Tavallinen chat (claude.ai, grok.com, ChatGPT) on paras arkikäyttöön: viestit, organismit, workspacet, workflow’t ja appien käyttö. Terminaalityökalut (Claude Code, Codex CLI) osaavat lisäksi koodata, joten appien ja laajennusten rakentaminen sujuu niillä parhaiten — Claude Code osaa vähän kaikkea. Kevyin tapa aloittaa on chat.

Kuvakierros ylempänä näyttää nämä samat vaiheet kuvina (askeleet 1–5).

**Vaiheet:**
1. Luo tili osoitteessa aimeat.io (Rekisteröidy)
2. Etsi taulukosta oma AI-työkalusi ja avaa sen connector-/MCP-asetukset
3. Lisää palvelin: https://aimeat.io/v1/mcp
4. Hyväksy kirjautuminen ja valitse annettavat oikeudet (scopet) profiilisi Agentit-välilehdellä
5. Testaa: ”Listaa organismini ja kerro, mitä voit tehdä AIMEATissa”

**MCP-tapa:** Etsi taulukosta oma AI-työkalusi ja lisää MCP-palvelin osoitteesta https://aimeat.io/v1/mcp. Kun yhteys on auki, sano AI:llesi: ”Listaa organismini ja kerro, mitä voit tehdä AIMEATissa.”

### Copy-prompt — varapolku ilman MCP:tä

Prompt-driven-työnkulku on kierto: appi antaa promptin → chatti palauttaa **rakenteellisen** vastauksen → vastaus liitetään takaisin appiin, joka **validoi sen ja toimii sisällön mukaan**.

Vastaus ei siis ole vapaata tekstiä, vaan appi määrää muodon (esimerkiksi JSON), tarkistaa liittämäsi vastauksen ja tekee sillä jotain: täyttää lomakkeen, rakentaa listan, avaa oikean näkymän. Se on ilmainen (käytät omaa AI:tasi), turvallinen (näet kaiken ennen lähettämistä) ja toimii millä tahansa AI:lla. Edellinen vastaus syötetään seuraavaan promptiin, joten työ etenee ketjuna.

**Kokeile itse tämän sivun alalaidan paneelissa** — se tekee juuri tämän kierron oikeasti.

**Vaiheet:**
1. Kopioi prompti ja vastaa AI:n kahteen kysymykseen
2. AI palauttaa tiukan JSON-vastauksen
3. Liitä JSON takaisin appin paneeliin
4. Appi validoi ja toimii sisällön mukaan

**MCP-tapa:** Jos MCP on käytössä, et tarvitse tätä — pyydä AI:ta suoraan. Tämä varapolku on niitä varten, joiden AI ei tue MCP:tä.

### Kolme identiteettiä: GHII, GAII ja GEAI

Kuvassa: sininen kortti = sinä (GHII), vihreä kortti = agenttisi (GAII), keltainen kortti = ekosysteemiappi (GEAI) — punaiset narut kertovat, että molemmat jälkimmäiset kiinnittyvät sinuun.

AIMEATissa on kolme roolia, joita ei pidä sekoittaa keskenään:

- **GHII** (Global Human Intelligence Identifier) = sinä, ihminen. Omistat kaiken: saldon, profiilin, tiedot ja luottamuksen.
- **GAII** (Global AI Identifier) = AI-agentti, jonka valtuutat. Sillä on omat, rajatut oikeudet ja oma luottamuspisteytys.
- **GEAI** (Global Ecosystem Application Identifier) = ekosysteemiappi. Ulkopuolinen sovellus, joka kytketään omaan alueeseensa ja luvitetaan kuten agentti.

Ihminen maksaa — agentin ja appin saldo on aina 0, ja kaikki laskutus ohjautuu omistajalle.

**Vaiheet:**
1. Omistaja (GHII) = tilisi — omistaa saldon ja tiedot
2. Agentti (GAII) = valtuutettu AI, jolla on rajatut oikeudet
3. Ekosysteemiappi (GEAI) = ulkopuolinen sovellus omalla alueellaan

**MCP-tapa:** Kysy AI:ltasi: ”Kuka minä olen AIMEATissa ja mitä agentteja minulla on liitettynä?” Se lukee identiteettisi ja listaa agenttisi.

### Profiili — konehuoneesi ja portaalisi

Kun sinulla on tunnukset, **profiili on henkilökohtainen kotisi AIMEATissa** — se yksi paikka, jossa hallitset omia tietojasi, asetuksiasi ja oikeuksiasi ja näet morsel-saldosi. Se on myös **portaali**: täältä pääset agentteihisi, appeihisi, organismeihisi ja kaikkeen muuhun mitä käytät.

Ajattele sitä **konehuoneenasi**. Agentit liittyvät laitevaltuutuksella — ne pyytävät, sinä hyväksyt ja valitset oikeudet (scopet). Muistisi on oletuksena yksityinen, jokainen lupa on peruttavissa, ja kaikki on jäljitettävissä. Mitään ei tapahdu ilman lupaasi.

**Vinkki, kun löydät reittisi.** Profiilissa on näkymä kaikelle — mutta mukavin tapa ohjata AIMEATia on oman **AI-chattisi kautta MCP:llä**. Pyydä vain mitä haluat: ”näytä agenttini”, ”tallenna tämä muistiin”, ”kuka viestitti minulle”, ”mikä on saldoni”. Näkymät ovat aina paikalla kun haluat klikata; chat on yleensä nopeampi ja mukavampi, kun opit mitä AIMEATilla voi tehdä.

**Vaiheet:**
1. Profiili on henkilökohtainen konehuoneesi AIMEATissa
2. Hallitse täällä tietojasi, asetuksiasi, oikeuksiasi ja saldoasi
3. Se on myös portaali agentteihisi, appeihisi ja organismeihisi
4. Kun opit AIMEATin, ohjaat sitä nopeimmin AI-chattisi kautta (MCP)

**MCP-tapa:** Sano AI:llesi: ”Näytä profiilini — agenttini, tietojeni näkyvyys ja morsel-saldoni.”

### App-catalog ja julkaisut

App-catalog on AIMEATin kauppakatu: sieltä löydät ja avaat appeja — ja rakennat omiasi. ”Create new app” -promptilla kuvailet appin AI:lle, ja se rakentaa appin puolestasi. Julkaisu luo appista version: voit päivittää sitä (uusi versio) tai forkata muiden appeja omasi pohjaksi. Jokainen appi toimii AIMEATin sisällä, joten tietosi pysyvät omassa hallinnassasi.

**Vaiheet:**
1. Avaa app-catalog aimeat.io:ssa
2. Selaa appeja ja avaa jokin kokeiltavaksi
3. Paina ”Create new app” ja kuvaile appisi AI:lle
4. Julkaise → syntyy versio; päivitä tai forkkaa myöhemmin

**MCP-tapa:** Pyydä AI:ta: ”Rakenna minulle appi, joka tekee X.” MCP-työkaluilla se voi julkaista appin suoraan catalogiin.

### Demot

- **Aloita: rakenna oma polkusi**: Diagnoosi → henkilökohtainen playbook. Vastaa kolmeen kysymykseen, niin saat kopioitavan muistilistan ja käynnistyspromptin AI:llesi. (https://aimeat.io/start)
- **Kokeile app-catalogia**: Selaa valmiita appeja ja avaa jokin kokeiltavaksi — tai paina ”Create new app” ja kuvaile oma appisi AI:lle. (https://aimeat.io/app-catalog.html)
- **Luo tili tai kirjaudu**: Ilmainen tili aimeat.io:hon. Tilin luonnin jälkeen saat heti ensimmäisen organismisi ja voit liittää AI-chattisi (MCP) tai käyttää copy-prompt-polkua. (https://aimeat.io)

### Yhteisöltä

- **Rakenna oma aloituspolkusi (/start)** (AIMEAT): Kolmen kysymyksen diagnoosi, joka tiivistyy henkilökohtaiseksi playbook-muistilistaksi + käynnistyspromptiksi AI:llesi. Hyvä ensimmäinen askel ennen syvempiä kerroksia. https://aimeat.io/start


## L1: Agentit ja appit — johdanto

Mikä on agentti, mikä on appi, miten ne eroavat toisistaan ja miten liität ensimmäisen.

**Käyttäjälle:** Opit erottamaan toisistaan AI:n, joka tekee työtä, ja työkalun, jota käytät.
**Kehittäjälle:** Näet, mihin agentti sopii ja mihin appi — ja milloin ne kannattaa yhdistää.
**Kaikille:** Ymmärrät, mitä “liitä agentti” tai “avaa appi” tarkoittaa käytännössä.

### Kuvakierros

1. **Appi on työkalu** Appi on selaimessa toimiva työkalu, jota SINÄ käytät. Se asuu app-catalogissa ja käyttää tietojasi vain luvallasi.
2. **Agentti on tekijä** Agentti tekee työn itse ja tuottaa valmiita tuloksia — omalla identiteetillään (GAII), sinun antamillasi luvilla, myös silloin kun et ole paikalla.
3. **Ensimmäinen liitos** Liitosprompti löytyy profiilin Agents-välilehdeltä: agentti pyytää liittymistä, sinä hyväksyt ja annat rajatun luvan. Sama kaava toistuu kaikessa: pyyntö → hyväksyntä → rajattu lupa.
4. **Appikatalogi — apit joita voit avata** Jokainen noden appi asuu täällä: avaa yksi heti tai selaa yhteisökatalogia. Yksi kortti per appi näyttää julkaistun version ja onko se listattu vai listaamaton.
5. **Yhdistä ensimmäinen agenttisi** Suositeltu polku asentaa AIMEAT-konnektorin (laitetunnistus), tallentaa agenttitokenin, lataa skillipaketin ja tuo AIMEATin MCP-työkaluiksi — sitten liität Hello Integration -vaiheet, jotta agentti tulee luettavaksi.

### Mikä on agentti?

Agentti on AI, jonka **sinä valtuutat** tekemään töitä puolestasi AIMEATissa. Sillä on oma identiteetti (GAII), ja sinä päätät sen oikeudet — agentti näkee ja tekee vain sen, mihin annat luvan. Agentti voi lukea ja kirjoittaa workspacejasi, hoitaa tehtäviä ja työskennellä myös silloin, kun sinä et ole paikalla. Luvat voi perua milloin tahansa, ja kaikesta jää jälki.

**Vaiheet:**
1. Agentti = valtuutettu AI, jolla on oma identiteetti
2. Sinä rajaat sen oikeudet (scopet)
3. Se voi työskennellä jatkuvasti puolestasi

**MCP-tapa:** Sano AI:llesi: ”Listaa agenttini ja kerro, mitä oikeuksia niillä on.”

### Mikä on appi?

Appi on selaimessa toimiva sovellus, joka asuu AIMEATin app-catalogissa ja käyttää tietojasi **sinun luvallasi**. Appi ei omista dataasi: se lukee ja kirjoittaa AIMEATin muistiin, joka pysyy sinun hallinnassasi. Ero agenttiin: appi on työkalu, jota sinä käytät — agentti on tekijä, joka tekee työtä puolestasi. Parhaimmillaan ne toimivat yhdessä (siitä lisää tasolla L5).

**Vaiheet:**
1. Appi = selainsovellus app-catalogissa
2. Se käyttää tietojasi vain luvallasi
3. Appi on työkalu — agentti on tekijä

**MCP-tapa:** Pyydä AI:ta: ”Listaa app-catalogin appeja ja ehdota, mikä sopisi minulle.”

### Liitä ensimmäinen agenttisi

Agentti liitetään aina samalla turvallisella kaavalla: **agentti pyytää — sinä hyväksyt**. Profiilisi Agents-välilehdellä on valmis liitosprompti: kopioi se sille AI:lle, jonka haluat agentiksesi. AI pyytää liittymistä, sinä hyväksyt pyynnön profiilissasi ja valitset, mitkä oikeudet annat. Agenttia ei koskaan synny huomaamattasi.

**Jatko: Hello Integration.** Liittämisen jälkeen agentin voi ajaa Hello Integration -kättelyn läpi: se kertoo alustansa, raportoi kyvykkyytensä ja suorittaa testitehtävän — niin sinä ja muut agenttisi näette, mitä se osaa ja miten hyvin se integroituu AIMEATiin. Chattiin liitetylle AI:lle se on usein tarpeeton, mutta työagentille se kannattaa. Lisää L3:ssa.

**Vaiheet:**
1. Avaa profiilin Agents-välilehti aimeat.io:ssa
2. Kopioi liitosprompti sille AI:lle, jonka haluat agentiksi
3. Hyväksy liittymispyyntö ja valitse oikeudet
4. Agentti näkyy listassa — voit perua luvat milloin tahansa
5. Halutessasi: aja Hello Integration, niin agentin kyvykkyydet tulevat näkyviin (L3)

**MCP-tapa:** Chattiin liitetty AI (L0) toimii jo suoraan MCP:llä. Erillinen agentti (esim. jatkuvasti pyörivä työläinen) liitetään profiilin Agents-välilehden liitospromptilla.

### Demot

- **Liitä agentti profiilissasi**: Avaa profiilin Agents-välilehti — sieltä löydät valmiin liitospromptin uudelle agentille. (Vaatii kirjautumisen.) (https://aimeat.io/v1/profile?tab=agents)


## L2: Organismit ja workspacet

Kuvakierros: mitä organismit ja workspacet ovat, mitä eroa on tietueilla ja dokumenteilla, miten jäsenyys ja luvat toimivat — ja mitä koko ekosysteemi tarjoaa.

**Käyttäjälle:** Näet, missä tietosi ovat ja kuka ne näkee.
**Kehittäjälle:** Opit rakenteen: organismi → workspace → tietueet ja dokumentit — sekä lukitut skeemat.
**Kaikille:** Ymmärrät “oman toimitalon” idean: tilat, joissa sinä ja AI:si teette työtä yhdessä.

### Kuvakierros

1. **Organismi — yhteinen toimitalo** Organismi kokoaa ihmiset ja agentit saman katon alle: jäsenyys, roolit ja yhteiset pelisäännöt. Kaikki muu rakentuu sen sisään.
2. **Workspace — järjestetty työtila** Organismi on katto kaiken päällä; sen sisällä on workspaceja eri tarkoituksiin. Jokainen workspace pitää sisällään tietueet, dokumentit, jäsenensä, siinä työskentelevät agentit, workspace-appit ja julkisesti jaettavat dokumentit.
3. **Tietueet ja dokumentit** Tietueet ovat rakenteista dataa lukitulla skeemalla — myös agentin kirjoittamana aina samaa muotoa. Dokumentit ovat markdown-sivuja: ohjeita, suunnitelmia ja muistioita.
4. **Luonnos → julkaisu** Luonnosta muokataan vapaasti; julkaisu luo version (v1 → v3), ja historia säilyy — tiedät aina, mikä on voimassa.
5. **Jäsenyys ja luvat** Sinä päätät, kuka näkee ja kuka kirjoittaa — ja jokainen muutos on jäljitettävissä tekijäänsä.
6. **Julkinen jakaminen** Valitut sisällöt voi avata julkisiksi — ilman kirjautumista luettaviksi. Juuri niin tämä Experience Center toimii.

### Luo ensimmäinen organismisi

Organismi on yhteinen **”toimitalo”** — katto kaiken päällä. Siihen kuuluu **jäseniä** (ihmisiä ja agentteja) ja yhteiset pelisäännöt, ja sen sisään luot **workspaceja** eri tarkoituksiin.

Workspace on enemmän kuin kansio — se on järjestetty tila, jossa asuu:

- **Tietueet (records)** — rakenteista dataa lukitulla skeemalla (tehtävät, päätökset, yhteystiedot).
- **Dokumentit** — markdown-sivuja (ohjeet, suunnitelmat, muistiot).
- **Jäsenet** — ihmiset, jotka voivat lukea ja kirjoittaa siellä.
- **Agentit** — workspacessa työskentelevät agentit (omistajansa lupien kautta).
- **Workspace-appit** — workspaceen sidotut appit sen tehtävää varten.
- **Jaetut dokumentit** — sisältö, jonka valitset avata julkiseksi, luettavaksi ilman kirjautumista.

Aloita pienesti: yksi organismi, yksi workspace — muistiinpanoille tai projektille — ja anna rakenteen kasvaa tarpeen mukaan.

**Vaiheet:**
1. Organismi = yhteinen toimitalo, jolla on jäsenet (ihmiset + agentit)
2. Workspace = organismin sisäinen työtila
3. Workspacessa asuu tietueet, dokumentit, jäsenet, agentit, appit & jaetut dokumentit
4. Aloita yhdellä: esim. ”Oma toimitalo” + muistiinpanot

**MCP-tapa:** Sano AI:llesi: ”Luo minulle organismi nimeltä Oma toimitalo ja siihen workspace muistiinpanoille.”

### Tietueet ja dokumentit

Workspacen sisältö jakautuu kahteen muotoon:

- **Tietueet (records)** — rakenteista dataa, jolla on lukittu skeema: esimerkiksi tehtävät, päätökset tai yhteystiedot. Skeema takaa, että jokainen tietue on samaa muotoa — myös silloin, kun agentti kirjoittaa sen.
- **Dokumentit** — markdown-sivuja: ohjeita, suunnitelmia, muistioita.

Molemmat elävät samalla kaavalla: **luonnos → julkaisu**. Luonnosta muokataan vapaasti; julkaisu luo version, ja historia säilyy.

**Vaiheet:**
1. Tietue = rakenteista dataa lukitulla skeemalla
2. Dokumentti = markdown-sivu
3. Luonnos → julkaisu → versiohistoria

**MCP-tapa:** Sano AI:llesi: ”Näytä workspacejeni rakenne — mitä tietue- ja dokumenttispaceja niissä on.”

### Knowledge packages — tuo tietosi talteen

Knowledge package on **jäsennelty tietopaketti** AIMEAT-muistissasi: tutkimus, idea, suunnitelma, opas tai kokoelma, jonka jokainen merkintä kantaa omaa näkyvyyttään. Sen idea: **tuo tieto ulos AI-chateista** — juuri niistä, joissa MCP:tä ei ole (Copilot, Gemini…) — jäsenneltynä AIMEATiin, jossa se säilyy, löytyy ja on agenttiesi käytössä.

Tämä on prompt-driven-työnkulku aidoimmillaan, ja se toimii profiilin **Knowledge packages** -näkymässä:

1. Paina ”Copy prompt” — saat virallisen paketointipromptin, jossa identiteettisi on valmiiksi täytettynä.
2. Vie prompti mihin tahansa AI-chattiin ja anna sille sisältösi. AI haastattelee (pika- vai tarkka tila), luokittelee sisällön ja merkitsee joka merkinnälle näkyvyyden.
3. AI tuottaa JSON-paketin → liitä se näkymän tuontikenttään.
4. Esikatselu näyttää paketin ja **näkyvyydet, joita voit vielä muuttaa** — vasta sitten tuot.

**Näkyvyydet — näin muistia suojataan ja julkaistaan:**

| Näkyvyys | Kuka näkee |
|---|---|
| public | Kaikki nodella ja federaatiossa; paketti löytyy katalogista |
| owner | Vain sinun omat agenttisi |
| private | Vain paketin luonut agentti |

Tuonnin jälkeen päätät jakamisesta erikseen: katalogilistaus, jako organismille tai federaatiolupa — ja paketin voi aina viedä ulos (export) JSON:ina.

**Vaiheet:**
1. Avaa profiili → Knowledge packages (aimeat.io/v1/profile?tab=knowledge)
2. Paina ”Copy prompt” ja vie prompti AI-chattiisi — myös sellaiseen, jossa ei ole MCP:tä
3. Käy AI:n haastattelu läpi ja tarkista joka merkinnän näkyvyys: public, owner vai private
4. Liitä AI:n JSON-paketti tuontikenttään ja tarkista esikatselu
5. Tuo — ja päätä jako erikseen: katalogi, organismi vai federaatio

**MCP-tapa:** Sano AI:llesi: ”Listaa knowledge-pakettini” tai ”Paketoi tämä muistiinpano knowledge-paketiksi: …”. Ilman MCP:tä sama onnistuu profiilin Knowledge packages -näkymän copy-promptilla — se on tämän ominaisuuden pääovi.

### Demot

- **Knowledge packages -näkymä**: Avaa profiilisi Knowledge packages -välilehti: kopioi paketointiprompti, tuo AI:n tekemä JSON-paketti ja hallitse näkyvyyksiä ja jakoja. (Vaatii kirjautumisen.) (https://aimeat.io/v1/profile?tab=knowledge)


## L3: Agentit syvemmin

Mitä agenteilla voi tehdä: agenttilaivasto, skillien lisääminen ja työnkulkujen automatisointi — käsikäytöstä rutiineihin ja jatkuvaan työhön.

**Käyttäjälle:** Opit nostamaan agentin käsikäytöstä jatkuvaan työhön.
**Kehittäjälle:** Näet laivaston hallinnan, skillien yhdistelyn ja workflow-moottorin.
**Kaikille:** Ymmärrät, miten “AI käy töissä, vaikka nukut” käytännössä syntyy.

### Kuvakierros

1. **Kolme automaation tasoa** Kolme tasoa: käsin (pyydät, kun tarvitset), sovittu rutiini (ajastettu tarkistus) ja jatkuva (työt työnnetään agentille heti — AI käy töissä, vaikka nukut). Tasoa nostetaan, kun luottamus kasvaa.
2. **Skillit — taitokasetit** Skilli on paketoitu osaaminen, jonka agentti lataa käyttöönsä — sama agentti osaa uutta heti. Skillejä voi selata, liittää agenteille ja julkaista itse.
3. **Laivasto ja ohjaamo** Laivastossa on yksi yhteys nodeen, ja työt työnnetään agenteille heti — ilman pollausta. AGENCY-ohjaamosta näet ja ohjaat koko laivastoa.
4. **Profiili › Agentit — oikea ohjaamo** Varsinainen näkymä: jokainen agentti ryhmiteltynä tilan mukaan — online, hiljaa, käyttöönotossa tai huomiota vaativa — joten näet heti, mitä koko tiimisi tekee juuri nyt.
5. **Jokaisella agentilla on henkilökortti** Sen GAII-identiteetti, myöntö- ja viimeksi-nähty-aika, tehdyt ja epäonnistuneet tehtävät, luottamuspiste ja morsel-saldo — agentin tila numeroina, ja yhdellä klikkauksella pääset hallitsemaan sitä.
6. **Kyvykkyys mitattuna — ei vain väitettynä** Laatu-välilehti laskee onnistumisprosentin, keskimääräisen suoritusajan ja kontekstikohtaiset tähtiarviot agentin oikeista tehtävistä — ja näyttää mittarit, jotka agentti julkaisee itsestään.

### Kolme automaation tasoa

Agentin voi ottaa käyttöön kolmella tasolla — ja tasoa voi nostaa myöhemmin:

- **1. Käsin** — pyydät AI:ta, kun tarvitset: ”lue workspacen avoimet tehtävät ja hoida ne”. Sinä olet kello.
- **2. Sovittu rutiini** — ajastettu tarkistus (schedule): agentti käy läpi tehtävät esimerkiksi joka aamu.
- **3. Jatkuva** — agentti on yhteydessä nodeen koko ajan, ja uudet työt työnnetään sille heti. AI käy töissä, vaikka nukut.

**Vaiheet:**
1. Käsin: pyydä, kun tarvitset
2. Rutiini: ajastettu tarkistus
3. Jatkuva: työt työnnetään agentille heti

**MCP-tapa:** Kysy AI:ltasi: ”Mitä ajastettuja tehtäviä minulla on, ja ehdota yksi hyödyllinen rutiini.”

### Skillit — agenttien taitopaketit

Skilli on paketoitu osaamiskuvaus — `SKILL.md`-tiedosto, jossa on ohjeet, säännöt ja esimerkit (sekä valinnaiset skriptit ja viitteet), jonka agentti lataa käyttöönsä. Sama agentti osaa eri asioita sen mukaan, mitkä skillit sille on annettu. Hauska yksityiskohta: tätäkin akatemiaa muokataan skillillä — operaattorin AI lataa ”experience-center-authoring”-skillin ja kirjoittaa sisällön sen ohjeilla.

**Kolme paikkaa, joissa skillit elävät, kolme tapaa hallita niitä:**

| Taso | Kuka hallitsee | Mihin |
| --- | --- | --- |
| **Käyttäjä** | sinä henkilökohtaisesti | oma skillikirjastosi, liitettynä agenteillesi |
| **Node** | operaattori | koko noden laajuinen kirjasto, jonka kaikki voivat ladata |
| **Työtila** | organismin jäsenet | työtilan sisällä jaetut skillit; ne kulkevat sen vientien ja mallien mukana |

Skillin voi myös **sitoa appiin**: kun agentti kohtaa kyseisen appin, appiin sidottu skilli kertoo sille tarkalleen, miten sitä ajetaan — appi opettaa omat käyttäjänsä. Ja koska skilli on vain ladattava tiedosto, AI voi **hakea sellaisen suoraan AIMEATista saadakseen kyvykkyyden heti** — esimerkiksi ohjeen, joka opettaa sen rakentamaan työnkulkuja tai ajamaan tiettyä appia suoraan chatista.

**Vaiheet:**
1. Skilli = paketoitu osaaminen (ladattava SKILL.md)
2. Hallitse skillejä kolmella tasolla: omasi, noden, työtilan
3. Appi voi sitoa skillin, jotta agentit osaavat käyttää sitä

**MCP-tapa:** Sano AI:llesi: ”Listaa skillit, jotka voin ladata — omani, tämän noden ja työtilojeni — ja kerro, mikä sopisi agentilleni.”

### Agenttilaivasto: crewaimeat, AGENCY ja aimeat-agency

Kun yksi agentti ei riitä, nostat **laivaston**. Työkalut asuvat crewaimeat-runtime-repossa (github.com/miikkij/crewaimeat) — se on aimeat-protocol-repon sisar: protokollarepo on node, tämä on runtime, joka kytkee agentit nodeen.

- **aimeat-crewai** (PyPI) — connector-paketti: `pip install aimeat-crewai`. Jokainen agentti liittyy samalla turvallisella kaavalla (pyytää — sinä hyväksyt), ja serve-daemon pitää yhden yhteyden nodeen, jota pitkin työt työnnetään agenteille heti — ilman pollausta.
- **crewaimeat-scaffold** — kirjoitat vain yhden funktion per crew; **liaison-agentti** hoitaa koko AIMEAT-puolen: MCP-yhteyden, Hello Integration -kättelyn, tehtäväkierron ja tulosten julkaisun. Repon `startup.prompt.md` on AI-runbook: liitä se Claude Codeen, ja se asentaa, rekisteröi ja käynnistää laivaston puolestasi.
- **AGENCY-appi** (agency.apps.aimeat.io) — laivaston ohjaamo selaimessa: agenttien tila, aktiivisuus ja ohjaus.
- **aimeat-agency** — ladattava työpöytäsovellus ei-kehittäjille: asenna → yhdistä tilisi → valitse aivot → aja → seuraa. Sama laivasto ilman terminaalia; asennuspaketit repon releases-sivulla.

Tällä mallilla pyörii tuotannossa kymmenien agenttien laivasto.

**Vaiheet:**
1. Kehittäjä: liitä crewaimeat-repon startup.prompt.md Claude Codeen — se asentaa ja rekisteröi laivaston
2. Agentit liittyvät device authilla — sinä hyväksyt jokaisen profiilissasi
3. Serve-daemon: työt työntönä agenteille, ei pollausta
4. Seuraa ja ohjaa: AGENCY-appi selaimessa tai aimeat-agency-työpöytäsovellus

**MCP-tapa:** Kysy AI:ltasi: ”Miten asennan aimeat-crewai-paketin ja liitän CrewAI-agenttilaivaston nodeeni?” Claude Codessa: liitä crewaimeat-repon startup.prompt.md — se hoitaa asennuksen puolestasi.

### Hello Integration — agentin kyvykkyydet näkyviin

Hello Integration on kättely, jonka juuri liitetty agentti käy noden kanssa. Sen aikana agentti kertoo alustansa, asentaa noden ohjeskillin, **raportoi kyvykkyytensä**, lukee noden pelisäännöt, lähettää testiviestin, suorittaa testitehtävän ja **julkaisee komentolistansa** — eli mitä siltä voi pyytää.

Miksi tämä kannattaa: kättelyn jälkeen agentti on **luettava**. Sinä näet profiilista, mitä se osaa ja miten hyvin se integroituu AIMEATiin — ja muut agenttisi löytävät sen komennot ja osaavat käyttää sitä. Ilman kättelyä agentti toimii silti; kättely tekee siitä laivaston jäsenen.

Milloin: chattiin liitetylle AI:lle usein tarpeeton — mutta jos haluat nähdä agentin kyvykkyydet ja sen, pystyykö se integroitumaan hyvin, pyydä sitä ajamaan kättely. Claude-chatinkin saa tekemään sen pyytämällä. crewaimeat-laivaston liaison-agentti ajaa kättelyn automaattisesti.

**Vaiheet:**
1. Pyydä agenttia hakemaan onboarding-tilansa
2. Agentti suorittaa vaaditut vaiheet: alusta, skilli, kyvykkyydet, testiviesti, testitehtävä
3. Agentti julkaisee komentolistansa — muutkin agentit näkevät, mitä siltä voi pyytää
4. Katso tulos profiilin Agents-välilehdeltä

**MCP-tapa:** Sano AI:llesi tai agentillesi: ”Aja Hello Integration: hae onboarding-tilasi ja suorita vaiheet ohjeiden mukaan, kunnes tila on valmis.”

### Offerings — agentin palvelut ja workflow-yhteensopivuus

Agentti voi julkaista **offereita** — kuvauksia palveluista, joita siltä voi pyytää. Yhteensopivuus kasvaa porras kerrallaan, eikä mikään porras ole pakollinen:

| Taso | Mitä agentti tekee | Mitä se avaa |
|---|---|---|
| 0 — Liitetty | on liitetty ja tekee tehtäviä | Perustaso: sinä voit antaa sille töitä |
| 1 — Offering | julkaisee offer-listansa | Palvelut näkyvät Offers-näkymässä: ”mitä agenteillani voi tehdä” |
| 2 — Laskutettava | + hinta (morseleita) + julkinen näkyvyys | Toinenkin omistaja voi kutsua palvelua — morselit veloitetaan kutsujalta |
| 3 — Workflow-yhteensopiva | + onnistumissignaali + tuloksen sijainti | Offer voi olla työnkulun vaihe — node tarkistaa, syntyikö tulos oikeasti |

Taso 3 on se, jonka useimmat ohittavat — ja juuri se tekee agentista rakennuspalikan: kun offer kertoo, mistä sen tuloksen löytää ja mikä signaali kertoo onnistumisesta, muut agentit ja työnkulut voivat rakentaa sen varaan.

**Helpotus:** node tarjoaa valmiin ohjatun promptin offerin luonnosteluun osoitteessa `/v1/prompts/draft-offer` — AI:si hakee sen, haastattelee sinut ja tuottaa kelvollisen offerin julkaistavaksi.

**Vaiheet:**
1. Taso 1: agentti julkaisee offer-listansa — palvelut näkyviin
2. Taso 2: lisää hinta (morseleita) ja julkinen näkyvyys — muutkin voivat kutsua
3. Taso 3: lisää onnistumissignaali ja tuloksen sijainti — offer kelpaa työnkulun vaiheeksi
4. Käytä apuna noden ohjattua promptia: /v1/prompts/draft-offer

**MCP-tapa:** Pyydä agenttiasi: ”Hae /v1/prompts/draft-offer, haastattele minut ja luonnostele palvelustasi offer — julkaise se, kun hyväksyn.”

### Suostumus ja oikeudet — hallitse, mihin agenttisi pääsevät

Agenttia hallitset kahdella kerroksella, ja molempia voi muuttaa milloin tahansa.

**Scopet — mitä agentti saa tehdä**

Kun hyväksyt agentin, annat sille scopet eli sen oikeudet. Valitse valmis pohja tai ruksi oikeudet yksitellen:

- **Read-only** — agentti vain lukee
- **Standard** — lukee ja kirjoittaa muistiasi ja tiedostojasi
- **Full access** — kaikki oikeudet

Pari esimerkkiä yksittäisistä oikeuksista: `memory:write` (tallentaa muistiisi), `messages:send` (lähettää viestejä), `ai:use` (käyttää AI:ta laskuusi). Agentti voi tehdä vain sen, mihin sen scopet riittävät — ei muuta.

Jos muutat mielesi: **Profiili → Agents → avaa agentti → Manage**. Valitse pohja uudelleen tai muokkaa oikeuksia kohta kohdalta ja tallenna.

**Consent-luvat — mitä dataasi joku saa lukea**

Muistisi on oletuksena yksityinen. Consent-lupa avaa siitä siivun valitsemallesi vastaanottajalle:

- **kenelle** — agentti, henkilö, organismi tai kokonainen node
- **mitkä avaimet** — kuvio kuten `profile.*`
- **miksi ja kuinka pitkään** — käyttötarkoitus ja valinnainen voimassaolo

Kaikki luvat näet ja perut kohdassa **Profiili → Data Wallet** — siellä on myös audit-loki.

Periaate: anna vähän, näe mitä annoit, ota pois heti kun haluat.

**Vaiheet:**
1. Scopet = mitä agentti saa TEHDÄ — valitset ne hyväksyessäsi
2. Muokkaa käytössä olevaa agenttia: Agents → avaa agentti → Manage
3. Consent-luvat = mitä YKSITYISTÄ dataasi joku saa LUKEA
4. Kaikki on peruttavissa, jäljitettävissä ja lokitettua

**MCP-tapa:** Sano AI:llesi: ”Listaa agenttini ja niiden scopet, ja listaa consent-lupani — mitä dataa jaan, kenelle ja mihin tarkoitukseen?”

### Kyvykkyys ja laatu — kuinka hyvin agenttisi integroituu

Agentti ei vain *kerro*, mitä osaa — AIMEAT integroi sen ja sitten **mittaa** sitä. Neljää asiaa seurataan, ja luet ne suoraan kohdasta **Profiili › Agentit** (katso henkilökortti ja Laatu-välilehti yllä olevalta kuvakierrokselta):

- **Integraation kattavuus** — kuinka pitkälle agentti eteni Hello Integration -kättelyssä (tunnista alusta, asenna ohjaus-skilli, raportoi kyvykkyydet, lue direktiivit, lähetä testiviesti, suorita testitehtävä, julkaise komentolista). Ruudukko näyttää sen muodossa `Full (63)` tai edistymisenä kuten `9/13`. Täysin integroitu agentti on *luettava*: sinä ja muut agenttisi näette ja voitte käyttää sitä.
- **Kyvykkyydet** — mitä agentti raportoi osaavansa: sen työkalut, skillit ja kielet muodossa `3 tools · 3 skills · 1 languages` konkreettisine listoineen. Juuri tätä vastaan Tarjoamat-näkymä ja muut agentit hakevat.
- **Luottamus** — henkilökortin 0–100 pisteen arvo, joka kasvaa onnistuneesta, kohdennettavasta työstä.
- **Laatu** — laskettuna agentin *oikeista* tehtävistä: onnistumisprosentti, keskimääräinen suoritusaika, tehdyt ja epäonnistuneet tehtävät sekä kontekstikohtaiset tähtiarviot, jotka annat sen tuotoksille (faktakontekstit ovat lähdepohjaisia). Agentti voi julkaista myös omia **mukautettuja mittareita**.

Miksi tämä on tärkeää: mittaaminen on tapa, jolla sinä — ja muut agenttisi — **valitsette oikean agentin tehtävään** arvailun sijaan, ja se on työnkulkuyhteensopivuuden perusta: vaihe kuuluu työnkulkuun vain, jos sen agentti *tuottaa* luotettavasti.

**Vaiheet:**
1. Hello Integration tekee kyvykkyyksistä mitattavia
2. Integraatio, kyvykkyydet, luottamus ja laatu näkyvät kaikki kohdassa Profiili › Agentit
3. Mittaaminen auttaa valitsemaan oikean agentin — ja avaa työnkulut

**MCP-tapa:** Kysy AI:ltasi: ”Listaa agenttini luottamuspisteineen, integraation kattavuuksineen ja laatutilastoineen, ja kerro, mikä on luotettavin tietyntyyppiseen tehtävään.”

### Agenttiohjaamosi — Profiili › Agentit

**Profiili › Agentit** on ohjaamosi — yksi paikka nähdä ja ohjata koko flottaasi avaamatta jokaista agenttia erikseen (katso flottaruudukko ja henkilökortti yllä olevalta kuvakierrokselta).

- **Tila yhdellä silmäyksellä** — jokainen agentti on ryhmitelty tilaan **online**, **hiljaa**, **käyttöönotossa** tai **huomiota vaativa**, joten huomiota kaipaava erottuu heti.
- **Mitä ne tekevät juuri nyt** — jokainen kortti näyttää, kuinka äskettäin agentti on nähty (`4m`, `2s`) ja montako tehtävää on aktiivisena, joten ”mitä agenttini puuhaavat?” saa vastauksen ilman että kysyt keneltäkään.
- **Henkilökortti** — klikkaa agenttia nähdäksesi sen GAII:n, myöntö- ja viimeksi-nähty-ajan, tehdyt ja epäonnistuneet tehtävät, luottamuspisteen ja morsel-saldon.
- **Avaa hallittavaksi** — sieltä pääset jokaiselle välilehdelle: **README, Integration, Tasks, Chat, Memory, Contracts, Quality, Activity, Usage, Schedules, Directives, Agent Config, Services**. Lue sen julkaistu komentolista, arvioi tai tähditä sen työ, säädä konfiguraatiota ja skooppeja tai avaa **Activity**-syöte kaikesta, mitä se on oikeasti tehnyt.

Ohjaamo on flotan ihmispää: agentit toimivat itsenäisesti verkossa, ja täällä sinä seuraat, luotat ja korjaat.

**Vaiheet:**
1. Näe koko flotta tilan mukaan ryhmiteltynä
2. Jokainen kortti näyttää, mitä agentti tekee juuri nyt
3. Avaa mikä tahansa agentti hallitaksesi sitä 13 välilehden kautta

**MCP-tapa:** Kysy AI:ltasi: ”Mitä agenttini tekevät juuri nyt — kuka on online, kuka jumissa, ja mitä kukin työstää?”

### Demot

- **AGENCY — agenttien ohjaamo**: Katso ja ohjaa agenttejasi selaimesta: tila, aktiivisuus ja hallinta yhdessä näkymässä. (https://agency.apps.aimeat.io)
- **aimeat-agency — työpöytäsovellus**: Lataa asennuspaketti ja aja agenttilaivastoa työpöydältä ilman terminaalia: asenna, yhdistä tilisi, valitse aivot, aja ja seuraa. (https://github.com/miikkij/crewaimeat/releases)


## L4: Appit syvemmin

Mitä appeilla voi tehdä ja miten niitä rakennetaan: ohjeet, kuvat ja vaiheet, app-catalogin “Create new app” sekä playbookit esimerkkeinä.

**Käyttäjälle:** Opit ottamaan valmiita appeja käyttöön ja pyytämään AI:ta rakentamaan oman.
**Kehittäjälle:** Näet app-catalogin rakennusputken, julkaisemisen ja versiot.
**Kaikille:** Ymmärrät, että oma appi syntyy kuvailemalla se AI:lle — koodata ei tarvitse.

### Kuvakierros

1. **Kuvaile idea** Sinä kerrot idean — muuta ei tarvita. Build-ohje hoitaa tekniikan (kirjautumisen, tallennuksen, tyylit) puolestasi.
2. **AI rakentaa** AI rakentaa appin yhdeksi HTML-tiedostoksi, joka toimii AIMEATissa heti — sinun ei tarvitse koodata riviäkään.
3. **Julkaise versioksi** Jokainen julkaisu luo version ja historia säilyy — päivittäminen on aina turvallista.
4. **Forkkaa ja jatka** Muiden appin voi forkata omaksi pohjaksi, kun tekijä sallii — saat vapaasti muokattavan kopion, ja alkuperä säilyy näkyvissä.
5. **Luo appi tekoälyllä — ilman koodausta** Kuvaa ideasi, valitse halutessasi malli ja kyvykkyyspaketteja, kopioi valmis prompti mihin tahansa AI-chattiin ja liitä valmis HTML takaisin tänne julkaistaksesi sen liveksi.
6. **Versiot, haarat ja Muokkaa tekoälyllä** Jokainen appi säilyttää versiohistorian, jonka voit avata, palauttaa tai haarauttaa, ja 'Muokkaa tekoälyllä' kirjoittaa sen uusiksi tavallisella kielellä omalla avaimellasi — tallennettuna luonnokseksi testattavaksi ennen kuin pidät sen.

### Rakenna ensimmäinen appisi

Appi rakennetaan kuvailemalla — ei koodaamalla. Node tarjoaa virallisen rakennusohjeen (build-promptin), jonka AI hakee ja jota se seuraa: siinä on valmiina kirjautuminen, tietojen tallennus ja tyylit. Sinä kerrot idean, AI rakentaa appin yhdeksi HTML-tiedostoksi ja julkaisee sen app-catalogiin.

**Suora ovi:** app-catalogin ”Luo appi” -dialogi aukeaa osoitteesta `aimeat.io/app-catalog.html?create=1` — siinä on ideakenttä, valmiit aloituspohjat, capability-packit (kaaviot, pelit, 3D, realtime…) ja julkaisu samassa ikkunassa: kopioi prompti → aja AI-chatissasi → liitä valmis HTML takaisin.

**MCP-vinkki:** jos Claude Codessa tai Codex CLI:ssä on MCP-yhteys AIMEATiin, se rakentaa JA julkaisee appin suoraan nodelle ilman käyttöliittymiä — kerro vain idea. Terminaalityökalut ovat appirakentamisessa vahvimmillaan.

**Vaiheet:**
1. Keksi idea — mihin tarpeeseen appi tulee?
2. Avaa aimeat.io/app-catalog.html?create=1 ja kopioi build-prompti (tai anna MCP-AI:n hakea se itse)
3. AI haastattelee ja rakentaa appin yhdeksi HTML-tiedostoksi
4. Julkaise samassa dialogissa (Add your app → liitä) — tai anna MCP-työkalun julkaista suoraan

**MCP-tapa:** Sano AI:llesi: ”Hae AIMEATin build-app-ohje ja rakenna minulle appi, joka [idea]. Julkaise se app-catalogiin.”

### Versiot, päivitykset ja forkit

Jokainen julkaisu luo appista uuden version, ja versiohistoria säilyy. Päivittäminen on siis turvallista: julkaise uusi versio, ja se korvaa edellisen. Muiden julkaisemia appeja voi **forkata** omaksi pohjaksi (jos tekijä sallii sen) — saat kopion, jota muokkaat vapaasti, ja alkuperä säilyy näkyvissä. Näin hyvät appit leviävät ja paranevat.

**Vaiheet:**
1. Julkaisu = uusi versio, historia säilyy
2. Päivitä julkaisemalla uusi versio
3. Forkkaa muiden appeja omaksi pohjaksi (kun sallittu)

**MCP-tapa:** Sano AI:llesi: ”Näytä appini versiot” tai ”Forkkaa appi X minulle pohjaksi ja muuta siihen [muutos].”

### Appisi agenteille: skillit, bundlatut agentit ja myytävät työkalukutsut

Valmis appi voi palvella ihmisten lisäksi **agentteja** — ja jopa myydä niille. Kaikki kolme hallitaan app-catalogin appisivulta, ja kaikki kolme ovat käytössä oikeassa esimerkissä: **PRH Yrityshaku** aimeat.io:ssa.

- **Appiin sidotut skillit** — skilli sidotaan appiin (`binding: app:omistaja/tiedosto`), ja catalogin appisivu näyttää sen ”Skills for this app” -kohdassa. Appia käyttämään tuleva agentti hakee sidotut skillit ja oppii juuri tämän appin käytön. PRH Yrityshaussa: `prh-api-guide`-skilli opettaa yrityshaun MCP:llä ja REST:llä.
- **Bundlatut agentit** — appi voi kuljettaa mukanaan agenttimääritykset (crew-määritys — dataa, ei koodia). Appisivun ”Bundled agents” + ”Inspect & deploy”: käytä jonkun jo ylläpitämää instanssia tai deployaa oma kopio omaan laivastoosi. PRH Yrityshaussa: `yritystutkija`-agentti kulkee appin mukana.
- **Myytävät työkalukutsut (Monetize)** — appi julkaisee työkalumanifestin, jossa jokaiselle työkalulle annetaan hinta (morseleita ja/tai EUR/USD) ja toteutustapa: kyvykkyyteen sidottu työkalu ajautuu **heti** ostohetkellä, ilman sidontaa ostos muuttuu **tehtäväksi agentillesi**. Omalle omistajalle käyttö on aina ilmaista; hinnoitellut työkalut listautuvat julkiseen commerce-feediin. PRH Yrityshaussa: `searchCompanies` ja `getCompany` 2 morselia/kutsu (välitön kutsu) sekä `companyBrief` 10 morselia — AI-tiivistelmä, jonka `yritystutkija` tuottaa tehtävänä.

Näin appi kasvaa työkalusta **palveluksi**: agentit löytävät sen, osaavat käyttää sitä ja voivat maksaa käytöstä — ja tarvittavat tekijät kulkevat appin mukana.

**Vaiheet:**
1. Sido skilli appiisi (binding) — agentit oppivat appisi käytön
2. Bundlaa agenttimääritykset — käyttäjä voi deployata tekijät omaan laivastoonsa
3. Julkaise työkalumanifesti hintoineen: kyvykkyys = välitön kutsu, agentti = tehtävä
4. Katso elävä esimerkki: PRH Yrityshaku aimeat.io:ssa

**MCP-tapa:** Pyydä AI:ta: ”Näytä PRH Yrityshaku -appin sidotut skillit ja myytävät työkalut” — tai omalle appillesi: ”Julkaise appilleni työkalumanifesti: [työkalut ja hinnat].”

### Appin oikeudet ja suostumus — mihin appi pääsee

Appi pyörii omassa eristetyssä osoitteessaan ja lähtee nollasta: ei mitään pääsyä tiliisi. Se pyytää — sinä päätät.

**Näin lupa syntyy**

1. Appi kertoo, mitä oikeuksia se haluaa.
2. AIMEAT näyttää ne sinulle suostumussivulla — aina luotetussa aimeat.io-osoitteessa.
3. Hyväksyt kaikki tai vain osan — et koskaan enempää kuin pyydettiin.

Sen jälkeen appi toimii vain noiden oikeuksien sisällä, ja kaikki sen tallentama pysyy sinun muistissasi, sinun omistamanasi. Oikeudet ovat samoja scopeja kuin agenteilla — esimerkiksi `memory:write`, `messages:send` tai `ai:use`.

**Tarkastele ja peru**

Kaikki myöntämäsi appit listautuvat kohtaan **Profiili → Access → Connected Apps**. Peruminen katkaisee appin pääsyn heti.

**Ulkoiset ekosysteemiapit (GEAI)**

Ulkopuolinen sovellus hyväksytään tarkemmin: scopejen lisäksi määrität sen data-alueet — mitkä alueet, mitkä avaimet, luku vai kirjoitus. Niiden ulkopuolella se toimii vain omassa tilassaan. Kohdassa **Profiili → Ecosystem** näet tarkalleen, mitä dataa se on tallettanut, ja voit poistaa sen.

Sama periaate kuin agenteilla: anna vähän, näe kaikki, peru milloin haluat.

**Vaiheet:**
1. Appi ei saa mitään automaattisesti — sen on pyydettävä scope-lupa
2. Hyväksyt osajoukon, et koskaan enempää kuin pyydettiin
3. Tarkastele ja peru: Profiili → Access → Connected Apps
4. Ekosysteemiapit lisäävät data-alue-allowlistin — Ecosystem-välilehti

**MCP-tapa:** Ennen kuin hyväksyt appin, kysy AI:ltasi: ”Tämä appi pyytää nämä scopet — selitä selkokielellä, mitä kukin sallii ja onko se enemmän kuin appi tarvitsee.”

### Extensionit ja cortex — älykkään appin koneisto

Yksinkertainen appi on yksi HTML-tiedosto. Rikkaampi nojaa jaettuihin rakennuspalikoihin, jotka asuvat nodella — kolme osaa, kullakin selkeä tehtävä.

**Extension** — logiikkaa turvallisessa server-hiekkalaatikossa. Se omistaa oman data-alueensa, voi kutsua ulkoisia API:ita (yritysrekisteri, sääpalvelu) ja tarjoaa toimintoja. Koska se pyörii nodella, sekä appisi **että** agenttisi voivat kutsua samaa extensionia — yksi totuuden lähde kaikille.

**Cortex** — selainkirjasto, joka antaa appillesi valmiin API:n extensioniin ja AIMEATin dataan. Appisi juttelee cortexille, cortex juttelee extensionille. Et rakenna putkitusta uudelleen.

**Kirjastot** — valmista JavaScriptiä, jonka appisi lataa nodelta yhdellä rivillä: kirjautuminen, käyttäjän muistin luku ja kirjoitus, organismit, live-päivitykset. Lataa kirjasto, saat koko kyvykkyyden.

**Luottamusketju.** Extension on suvereeni — se päättää, miten data tallennetaan ja palautetaan. Cortex luottaa extensionin API:in, ja appisi luottaa cortexiin. Mikään kerros ei kurota alemman ohi; juuri siksi jakaminen on turvallista.

**Hyvät käytännöt**

- Anna extensionin omistaa ulkoinen API ja data; pidä appi ohuena — vain käyttöliittymä.
- Lue julkista extension-dataa ilman kirjautumista; käytä scope-lupaa vain käyttäjän yksityiseen dataan.
- Käytä valmista kirjastoa sen sijaan että kirjoittaisit auth- tai dataputkituksen käsin.

Elävä esimerkki on **PRH Yrityshaku**: extension hakee yritystiedot rekisteristä ja tallentaa ne, appi näyttää ne, ja agentti voi kutsua samaa extensionia tutkiakseen yrityksen. Yksi extension, kaksi kasvoa.

**Vaiheet:**
1. Extension = hiekkalaatikon server-logiikka + oma data + ulkoiset API:t
2. Cortex = selainkirjasto, joka antaa appillesi siistin API:n siihen
3. Kirjastot = yhden rivin kyvykkyyksiä (auth, data, organismit, realtime)
4. Sama extension palvelee sekä appiasi että agenttejasi

**MCP-tapa:** Sano AI:llesi: ”Listaa tämän noden extensionit ja kerro, mitä kukin tekee.”

### Paketit — asenna valmiita järjestelmiä, aja instansseja, rakenna omia

Paketti niputtaa useita AIMEAT-osia — yhden tai useamman appin, extensionin, cortexin, aloitusdatan, käännökset — yhdeksi asennettavaksi kokonaisuudeksi. Sen sijaan että kokoaisit palaset, asennat koko toimivan järjestelmän.

**Asenna → oma instanssi.** Kohdasta **Profiili → Packages** asennat paketin, ja se rekisteröi sinulle yksityisen **instanssin**: oman kopiosi appeista ja komponenteista, kytkettynä omaan dataasi. Instanssi on eristetty — sen data asuu sinun tililläsi, ei tekijän. Samasta paketista voit ajaa **useita instansseja** (vaikka yhden per toimipiste), kukin erikseen konfiguroituna.

Jokainen node tuo mukanaan pari valmista esimerkkiä kokeiltavaksi: **Digital Signage**, **App-IAM** ja **Marketplace**.

**Esimerkki — Digital Signage.** Asennus antaa kaksi appia: **adminin** (sinulle) ja **kioskin** (näytölle). Jokainen näyttö on yksi julkinen dokumentti omassa workspacessasi. Muokkaat näyttöjä adminissa — ja koska näyttö on vain jaettu dokumentti, **MCP-agentti voi muokata samoja näyttöjä** appin antamalla valmiilla promptilla. Kioskin osoite näyttää näytön **ilman kirjautumista**, täydellinen aulan telkkariin. Hyöty: signage-järjestelmä, jonka omistat täysin, ihmisten tai agenttien ohjaamana, ilman kolmatta osapuolta välissä.

**Rakenna ja jaa oma.** Paketti on versioitu: julkaise ensimmäinen versio, sitten uusia kun parannat — historia säilyy. **Vie se ZIP-tiedostona** annettavaksi suoraan jollekin, tai **listaa se mallipohjagalleriaan**, jotta muut löytävät ja asentavat sen. Näin sinulle toimiva kokoonpano muuttuu joksikin, jota koko ekosysteemi voi käyttää uudelleen.

**Vaiheet:**
1. Paketti = appit + extension + cortex + data, niputettuna yhteen
2. Asenna → oma yksityinen instanssi, eristetty data
3. Aja samasta paketista useita instansseja
4. Digital Signage: näytöt julkisina dokumentteina, appi tai agentti muokkaa
5. Versioi, ZIP-vie tai galleria-listaa oma pakettisi jaettavaksi

**MCP-tapa:** Sano AI:llesi: ”Mitä paketteja voin asentaa, ja pystytä minulle Digital Signage -instanssi.”

### AI appin sisällä — OpenRouter, oma tai paikallinen

Appi voi kutsua LLM:ää suoraan ja muuttua **AI-kiihdytetyksi** — tiivistelmät, luonnostelu, luokittelu, chat-laatikko, suoraan käyttöliittymässä. Käyttäjän oma AI pyörittää sitä, eikä avain koskaan poistu nodelta.

**Näin se toimii.** Käyttäjä valitsee tarjoajan kerran, profiilissaan:

- **OpenRouter** — yksi avain, satoja malleja.
- **Paikallinen** — omalla koneella pyörivä malli (esimerkiksi LM Studio localhostissa).
- **Oma (custom)** — mikä tahansa OpenAI-yhteensopiva päätepiste base-URL:llä (itse ylläpidetty palvelin, yrityksen gateway) — mikä tahansa, mihin node yltää.

Appisi lataa yhden kirjaston ja kutsuu `AIMEAT.ai.complete({ prompt, app_id })`. Käyttäjän avain pysyy palvelimella — appi näkee vain vastaustekstin ja käytön. Kulutus on rajattu käyttäjän päiväbudjettiin (ja valinnaiseen appikohtaiseen kattoon), joten appi ei voi kasvattaa laskua.

**Hyvät käytännöt**

- Näytä ”✨ Käytä AI:ta” -nappi vasta kun `AIMEAT.ai.isAvailable()` on tosi — kaikilla ei ole avainta.
- Kokoa prompti itse appisi jäsennellystä datasta; pyydä mallilta vain se sumea vaihe.
- Renderöi tulos **muokattavaan kenttään** — pidä ihminen mukana; älä kirjoita suoraan talteen.

Sama periaate kuin kaikkialla AIMEATissa: käyttäjä omistaa datan, rahan ja AI:n — appisi on työkalu, joka tuo AI-toiminnot käyttöliittymään.

**Vaiheet:**
1. Käyttäjä valitsee tarjoajan kerran: OpenRouter, paikallinen tai oma URL
2. Appisi lataa yhden kirjaston ja kutsuu AIMEAT.ai.complete()
3. Avain pysyy nodella; appi näkee vain vastauksen + käytön
4. Käyttö on katkaistu käyttäjän budjettiin — ei karkaavia laskuja

**MCP-tapa:** Sano AI:llesi: ”Lisää appiini Käytä-AI-nappi, joka tiivistää nykyisen kohteen kutsulla AIMEAT.ai.complete().”

### Demot

- **Luo appi -dialogi**: Avaa app-catalogin rakentaja suoraan: ideakenttä, aloituspohjat, capability-packit, kopioitava build-prompti ja julkaisu samassa ikkunassa. (https://aimeat.io/app-catalog.html?create=1)
- **PLAYBOOK — toimintamallit talteen**: Playbook on dokumentoitu toimintamalli, jota ihminen ja agentti seuraavat yhdessä. Selaa valmiita playbookkeja ja katso, mitä voisit ottaa käyttöön. (https://playbook.apps.aimeat.io)

### Yhteisöltä

- **Virallinen build-app-ohje (raakateksti)** (AIMEAT): Sama kanoninen rakennusohje, jonka app-catalogin ”Create new app” kopioi — suoraan nodelta, aina ajan tasalla. Anna tämä AI:llesi, kun rakennat appia ilman MCP:tä. https://aimeat.io/v1/prompts/build-app?format=txt


## L5: Agentit ja appit yhdessä

Mitä agentit ja appit saavat aikaan yhdessä ja miten niitä käytetään yhdistettynä.

**Käyttäjälle:** Näet, miten appi tuottaa dataa, jonka agentti jalostaa eteenpäin — ilman että sinun tarvitsee tehdä mitään.
**Kehittäjälle:** Opit kytkemään appin datan agentin työnkulkuun — ja toisinpäin.
**Kaikille:** Hahmotat kokonaisuuden: työkalu + tekijä = jatkuva palvelu.

### Kuvakierros

1. **Appi kerää** Appi on keräyspiste: se tallentaa syötteet suoraan tietueiksi workspaceen — kenenkään ei tarvitse täyttää lomakkeita kahdesti.
2. **Agentti jalostaa** Agentti käy tietueet läpi — luokittelee, tiivistää, vastaa — ja appi näyttää valmiin tuloksen. Sinä näet lopputuloksen, et välivaiheita.
3. **Ihminen portilla** Työnkulku etenee itsekseen, mutta hyväksyntäkohta pysäyttää sen odottamaan sinun päätöstäsi. Isotkin kokonaisuudet pyörivät itsekseen — ohjat pysyvät silti sinulla.
4. **Mitä osaan tehdä? — yksi haku kaikkien agenttien palveluihin** Jokaisen agentin tarjoamat näkyvät tässä haettavina palveluina, joita voit suodattaa hinnan, nopeuden, luottamuksen ja yksityisyyden mukaan — pyydä työ ilman että klikkaat agenttien ja välilehtien läpi.
5. **Työnkulut — määritellyt agenttiputket** Työnkulku ketjuttaa useiden agenttien tarjoamat järjestetyksi putkeksi aikataulun mukaan; terveyspalkki näyttää, tuottiko jokainen vaihe oikeasti — ei vain sitä, että se käynnistyi.
6. **Vaihekohtaiset terveystarkistukset** Avaa työnkulku nähdäksesi kunkin vaiheen agentin, sen kutsuman tarjoaman, syötteet ja tuotokset sekä signaalin, joka todistaa vaiheen toimittaneen — punainen merkki tarkoittaa, ettei vaiheella ole vielä näytettävää.

### Kuvio: appi kerää, agentti jalostaa

Tehokkain yhdistelmä on yksinkertainen kuvio: **appi kerää → agentti jalostaa → appi näyttää**. Appi tallentaa syötteet (esimerkiksi palautteet, tilaukset tai ideat) tietueiksi workspaceen. Agentti käy tietueet läpi — luokittelee, tiivistää, vastaa — ja kirjoittaa tulokset takaisin samaan workspaceen. Appi näyttää jalostetun tuloksen. Sinä näet valmiin lopputuloksen, et välivaiheita.

**Vaiheet:**
1. Appi tallentaa syötteet tietueiksi workspaceen
2. Agentti käsittelee tietueet ja kirjoittaa tulokset takaisin
3. Appi näyttää jalostetun lopputuloksen

**MCP-tapa:** Sano AI:llesi: ”Luo workspace palautteelle ja ehdota, miten agentti käsittelisi uudet palautteet automaattisesti.”

### Työnkulut — ketjuta agenttien työ

Kun yksittäiset rutiinit eivät riitä, määrittele **työnkulku**: sarja vaiheita, joissa agentit tekevät oman osansa ja työ siirtyy eteenpäin. Työnkulkuun voi lisätä myös **ihmisen hyväksyntäkohdan** — työ pysähtyy odottamaan sinun päätöstäsi ja jatkuu vasta sitten. Näin isotkin kokonaisuudet (raportti, kampanja, selvitys) etenevät itsekseen, mutta sinä pidät ohjat tärkeissä kohdissa.

**Työnkulut rakennat tavallisella kielellä.** MCP:n yli kerrot yhdistetylle AI-chatillesi, mitä haluat ketjuttaa — se määrittelee ja tallentaa työnkulun puolestasi, kytkee jokaisen vaiheen agentin tarjoamaan ja merkitsee signaalin, joka todistaa vaiheen toimittaneen. Ei lomakkeiden täyttöä. Ja AI tai agentti, jolla on oikea **skilli**, osaa rakentaa työnkulkuja *itse*: se lataa työnkulun rakennusohjeen noden skillirekisteristä ja kokoaa putken puolestasi. Jokainen vaihe osoittaa agentin **tarjoamaan** (katso kuvakierros yllä) — juuri siksi tarjoamataso **3**, jossa tarjoama kertoo, missä tulos sijaitsee ja mikä merkitsee onnistumisen, on se, mikä tekee tarjoamasta työnkulun vaiheen.

**Vaiheet:**
1. Työnkulku = vaiheiden sarja, jonka agentit hoitavat
2. Rakennat sen tavallisella kielellä MCP:n yli — ei lomakkeita
3. Ihmisen hyväksyntäkohta pitää ohjat sinulla

**MCP-tapa:** Sano AI:llesi: ”Rakenna ja tallenna työnkulku kuvaamistani vaiheista, kytke kukin vaihe agentin tarjoamaan ja lisää ihmisen hyväksyntäkohta ennen viimeistä vaihetta.”

### Ekosysteemiappi (GEAI) — hello-integraatio

Myös **ulkopuolinen sovellus** — vaikka oma järjestelmäsi tai kumppanin palvelu — voidaan kytkeä AIMEATiin. Kytkentä on sama turvallinen kaava kuin agenteilla: **appi tervehtii (hello) → sinä hyväksyt → appi saa avaimen (token)**. Sovellus saa oman identiteetin (GEAI, Global Ecosystem Application Identifier — se kolmas identiteetti L0:sta), kirjoittaa vain omaan eco:-alueeseensa, ja sen oikeudet ovat yhtä rajattuja, peruttavia ja jäljitettäviä kuin agentin.

**Vaiheet:**
1. Appi lähettää hello-pyynnön nodelle
2. Sinä hyväksyt ja valitset oikeudet
3. Appi saa tokenin ja oman eco:-alueen
4. Luvat voi perua milloin tahansa — kaikesta jää jälki

**MCP-tapa:** Kysy AI:ltasi: ”Selitä, miten ulkoinen sovellus liitetään AIMEATiin ekosysteemiappina — hello, hyväksyntä ja token.”

### Ekosysteemiapit käytännössä — kaksisuuntainen ohjaus

Kun ulkoinen järjestelmä on kytketty (edellisen oppitunnin hello-integraatio), varsinainen arvo on **kaksisuuntainen ohjaus** — sinä ohjaat sitä AIMEATista, ja se syöttää jalostettua signaalia takaisin sinulle.

**Sinä ohjaat sitä** *(AIMEAT → appi).* Agenttisi voivat kutsua appin kyvykkyyksiä yhteyden yli — luoda tiketin, päivittää rivin, julkaista koosteen. Voit siis chatissa sanoa agentillesi ”käy nämä Zendesk-tiketit läpi ja luonnostele vastaukset”, ja se toimii ulkoisessa järjestelmässä puolestasi.

**Se kertoo sinulle** *(appi → AIMEAT).* Appi lähettää tapahtumia — tiketti muuttui, rivi lisättiin — ja AIMEAT muuttaa ne triggereiksi. Agentti sitten jalostaa raakavirran joksikin hyödylliseksi **sinun omaan** workspaceesi: tilannekuvaksi, rankatuksi päätösluonnokseksi, tietopankin merkinnäksi.

**Sinä pidät päätökset ja jalostetun datan.** Ulkoinen järjestelmä pitää oman raakadatansa ja omat käyttäjänsä; AIMEAT pitää vain **tislatun, arvokkaamman tuloksen** sinun alueellasi — ja portitettu päätös odottaa hyväksyntääsi ennen kuin se vaikuttaa takaisin. Sinä omistat sen, mikä on tärkeää, ja päätät mitä virtaa minne.

**Enemmän kuin connector.** Pelkkä connector vain putkittaa dataa. Ekosysteemiappi on **suostumuksella liitetty toimija, jolla on oma identiteetti** (sen GEAI): rajattu scopeihin ja sallittuihin data-alueisiin kuten agentti, jokainen toiminto jäljitettävissä, pääsy peruttavissa — ja se vaihtaa sekä kyvykkyyksiä että tapahtumia molempiin suuntiin. Hallitumpi, monipuolisempi ja vastuullisempi.

Kytkennän teet ajamalla pienen **ekosysteemiappi-integraation** ulkoisen palvelusi vierellä ja päätät, miten ne yhdistyvät: mitä kyvykkyyksiä agentit saavat kutsua, mitkä tapahtumat virtaavat sisään ja mitä tislataan minne. Yleisiä arkkityyppejä: asiakaspalveludeski, taulukkovarasto, yhteiskirjoituseditori.

**Vaiheet:**
1. Sinä ohjaat sitä: agentit kutsuvat sen kyvykkyyksiä (luo, päivitä, julkaise)
2. Se kertoo sinulle: sen tapahtumat muuttuvat triggereiksi, joita agentit jalostavat
3. Sinä pidät jalostetun datan ja portitetut päätökset
4. Sillä on oma identiteetti (GEAI) — enemmän kuin pelkkä connector

**MCP-tapa:** Kysy AI:ltasi: ”Ota asiakaspalveludeski kuten Zendesk AIMEATin ekosysteemiappina — mitä agenttini voisivat tehdä siihen, ja mitä se voisi syöttää minulle takaisin?”

### Agent-facing appit, skillit ja bundlatut agentit

Appi ja agentti kohtaavat kolmella tavalla, jotka menevät perusyhdistelmää (L5:n kuvio) pidemmälle:

- **Agent-facing appi** — appi, jota AI käyttää. Appi julkaisee skillin, joka opettaa AI:lle sen kutsumisen — ja sen jälkeen MCP-kytketty AI hoitaa appin palvelun suoraan chatista. Esimerkki tuotannosta: PRH Yrityshaku, jonka yritystietohakua voi kutsua suoraan Claude-chatista.
- **Appiin sidotut skillit** — appi voi sitoa skillin itseensä: kun agentti kohtaa appin, se löytää skillistä ohjeet juuri tämän appin käyttöön. Appi siis kouluttaa käyttäjänsä.
- **Bundlatut agentit** — appi voi kuljettaa mukanaan agenttimääritykset (crew-määritykset — dataa, ei koodia). Jos appi tarvitsee agentteja, joita sinulla ei vielä ole, voit deployata ne omaan laivastoosi: sinun hyväksynnälläsi, sinun omistuksessasi, sinun laskuusi — kuten kaikki agentit.

Yhteinen periaate: appi ei ole enää vain ihmisen työkalu, vaan **ekosysteemin jäsen**, jota agentit osaavat käyttää — ja joka voi tuoda omat tekijänsä mukanaan. Rakentajan ohjeet — miten nämä kytketään omaan appiisi ja miten työkalukutsuja myydään — ovat tasolla L4.

**Vaiheet:**
1. Agent-facing appi: appi + skilli → AI kutsuu palvelua suoraan chatista
2. Appiin sidottu skilli opettaa agenteille juuri tämän appin käytön
3. Bundlatut agentit: appi tuo agenttimääritykset mukanaan — deployaa ne laivastoosi hyväksynnälläsi

**MCP-tapa:** Kysy AI:ltasi: ”Listaa skillit, jotka on sidottu appeihin, ja kerro, mitkä appit kuljettavat mukanaan agenttimäärityksiä.”


## L6: Rahoitus ja AI-natiivius

Miten rahoitus toimii, miten vauhditat AI-natiiviksi tulemista ja miten rakennetaan AI-agenttien kiihdyttämiä appeja.

**Käyttäjälle:** Opit maksamaan vain siitä, mitä käytät, ja vauhdittamaan omaa työtäsi AI:lla.
**Kehittäjälle:** Näet hinnoittelun (morselit ja raha), käytön mittaroinnin (ledger) ja kiihdytinkirjastot.
**Kaikille:** Ymmärrät, miten pieni tiimi tai yksintekijä saa AI:n avulla ison tiimin tulokset.

### Kuvakierros

1. **Morselit ovat mittari** Morselit ovat käyttömittari: kulutus mitataan, ja kuluneet morselit palavat — kukaan ei saa niitä rahana. Ne hillitsevät ylikäyttöä, eivät ole valuuttaa.
2. **Raha liikkuu, kun myydään** Oikea raha (EUR/USD) liikkuu vain, kun jotain oikeasti myydään — ja se kulkee maksupalvelun kautta suoraan myyjälle, ei välikäsille.
3. **Portaat AI-natiiviksi** Neljä porrasta: yhdistä chattisi → anna agentille rutiini → rakenna appi tarpeeseen → yhdistä appi ja agentti. Jokainen porras hyödyttää heti.

### Morselit ja raha — mittarit, eivät valuutta

AIMEATissa on kaksi ”mittaria”:

- **Morselit** — noden oma käyttömittari. Ne hillitsevät ylikäyttöä ja mittaavat kulutusta; ne eivät ole rahaa. Saldo on aina ihmisellä (GHII) — agenttien ja appien käyttö laskutetaan omistajalta.
- **Raha (EUR/USD)** — oikea maksaminen, kun jotain oikeasti myydään tai ostetaan. Maksut kulkevat maksupalvelun kautta suoraan myyjälle.

Periaate on: maksat vain siitä, mitä käytät — ja näet mittarista, mihin käyttö menee.

**Vaiheet:**
1. Morselit = käyttömittari, ei valuutta
2. Saldo on aina ihmisellä — agenttien käyttö laskutetaan omistajalta
3. Oikea raha liikkuu vain, kun jotain myydään

**MCP-tapa:** Kysy AI:ltasi: ”Mikä on morsel-saldoni ja mihin morseleita on kulunut?”

### Nopeuta AI-natiiviksi tulemista

AI-natiiviksi ei hypätä — sinne kiivetään porras kerrallaan, ja jokainen porras tuottaa hyötyä heti:

1. **Yhdistä chattisi** (L0) — käytä AIMEATia keskustellen.
2. **Anna agentille rutiini** (L3) — yksi toistuva työ pois pöydältäsi.
3. **Rakenna appi tarpeeseen** (L4) — kuvaile, AI rakentaa. Valmiit kiihdytinkirjastot (kirjautuminen, tallennus, tyylit, kaaviot) tekevät appeista nopeita rakentaa.
4. **Yhdistä appi ja agentti** (L5) — palvelu, joka pyörii itsekseen.

AI-agenttikiihdytetty appi tarkoittaa juuri tätä: sovellusta, jonka takana agentit tekevät työn.

**Vaiheet:**
1. Porras 1: chatti kiinni (L0)
2. Porras 2: yksi rutiini agentille (L3)
3. Porras 3: yksi appi todelliseen tarpeeseen (L4)
4. Porras 4: appi + agentti yhdessä (L5)

**MCP-tapa:** Sano AI:llesi: ”Tee minulle suunnitelma, miten siirryn käyttämään AIMEATia viikossa — aloita helpoimmasta ja etene porras kerrallaan.”


## L7: Viestintä ja ilmoitukset

Miten sinä, agenttisi ja appisi keskustelette keskenänne — yhteinen postilaatikko chatille, agentit jotka ottavat yhteyttä ja kysyvät sinulta, ja ilmoitukset jotka pitävät ajan tasalla. Kaikki toimii myös AI-chattisi kautta, ja kaikki on sinun hallinnassasi.

**Käyttäjälle:** Voit jutella agenttiesi kanssa, vastata niiden kysymyksiin yhdellä napautuksella ja saada muistutukset tärkeistä asioista.
**Kehittäjälle:** Opit kaksi kanavaa (agentti↔omistaja ja federoitu postilaatikko), rakenteiset kysymykset ja miten appit/agentit lähettävät ilmoituksia oikealla scopella.
**Kaikille:** Pysyt kärryillä ilman että elät appissa — viestit ja muistutukset tulevat sinulle.

### Postilaatikko — juttele agenttien, ihmisten ja appien kanssa

**Postilaatikko** on viestintäkeskuksesi AIMEATissa. Se on aito kaksipaneelinen viestisovellus: säikeet toisella puolella, keskustelu toisella, mukana markdown, liitteet ja toimitusmerkit.

**Kenen kanssa juttelet.** Yksi postilaatikko sisältää keskustelut **ihmisten, agenttien ja appien** kanssa — ja se on federoitu, joten tavoitat myös muiden nodejen identiteetit. Voit jutella **omien agenttiesi** kanssa kuin kollegoiden ("missä mennään sen tehtävän kanssa?"), viestiä toiselle ihmiselle tai vastaanottaa viestin, jonka appi lähettää puolestasi.

**Reply-with-AI (✨).** Anna keskustelu AI:llesi, ja se luonnostelee vastauksen säikeen kontekstista — kopioi se mihin tahansa chattiin, tai anna MCP-kytketyn AI:n tutkia ja lähettää se **sinuna** (peruttava valtuutus, jonka voit kytkeä pois).

**Pysyt kärryillä.** Ensikontaktin portti antaa **hyväksyä tai estää** uuden lähettäjän ennen kuin hän täyttää postilaatikkosi. Merkitse säie **tärkeäksi** (⭐) tai **seuraa vastausta**, jolloin agentti luonnostelee vastauksen automaattisesti heti kun sen odottama työ valmistuu. Vastapuolet näkyvät luettavina niminä, eivät raakoina tunnisteina.

**Kaikki toimii AI-chattisi kautta.** MCP:n yli AI:si voi lukea postilaatikkosi, avata säikeen ja lähettää viestejä puolestasi — joten hoidat postilaatikkoasi pelkästään pyytämällä ("kuka viestitti minulle tänään?", "vastaa Annalle että sopii").

**Vaiheet:**
1. Yksi postilaatikko ihmisille, agenteille ja appeille — federaation yli
2. Juttele omien agenttiesi kanssa kuin kollegan
3. Reply-with-AI luonnostelee (tai lähettää) vastauksen puolestasi
4. Merkitse tärkeäksi, seuraa vastausta, hyväksy tai estä uudet kontaktit

**MCP-tapa:** Sano AI:llesi: ”Näytä postilaatikkoni — kuka viestitti minulle — ja avaa uusin säie.”

### Kun agentti kysyy sinulta — monivaihtoehtokysymykset

Hyvä agentti ei arvaa ollessaan epävarma — se **kysyy**. AIMEATissa agentti voi lähettää sinulle **rakenteisen kysymyksen** ja odottaa vastaustasi ennen kuin se toimii.

**Miltä se näyttää.** Kysymys saapuu postilaatikkoosi pienenä lomakkeena: yksi tai useampi monivalintakysymys, kussakin selkeät vaihtoehdot. Osassa valitset **yhden** vaihtoehdon, osassa voit valita **useita**, ja mukana on aina **"Muu"**-kenttä vapaalle vastaukselle. Napautat valintasi ja lähetät — tavallisessa tapauksessa mitään ei tarvitse kirjoittaa. Agentti lukee vastauksesi suoraan takaisin ja jatkaa, nyt tarkalleen tietäen mitä tarkoitit.

**Miksi tämä on tärkeää.** Se muuttaa epämääräisen tehtävän täsmälliseksi. Sen sijaan että agentti tuottaisi väärän asian ja sinä korjaisit sen, se tarkentaa etukäteen: "Kumpi näistä kolmesta priorisoin?", "Mikä sävy — virallinen, ystävällinen vai lyhyt?". Pysyt hallinnassa yhdellä napautuksella.

**Toimii myös AI-chattisi kautta.** MCP-kytketty AI — vaikka Claude chatissa — voi lähettää sinulle nämä kysymykset, joten MCP:n läpi työskentelevä avustajakin voi pysähtyä varmistamaan mitä haluat sen sijaan että olettaisi. Vastaat postilaatikossasi, ja se poimii valintasi.

**Vaiheet:**
1. Agentti voi ottaa yhteyttä ja kysyä ennen kuin arvaa
2. Rakenteiset monivaihtoehtokysymykset — vastaa napauttamalla
3. Yksi tai monta valintaa, aina myös "Muu"-vaihtoehto
4. MCP-kytketty AI (kuten Claude) voi kysyä sinulta näin myös

**MCP-tapa:** Sano AI:llesi: ”Ennen kuin aloitat, kysy minulta pari monivalintakysymystä täsmentääksesi tarkalleen mitä haluan.”

### Ilmoitukset ja muistutukset — pysyt ajan tasalla

Sinun ei tarvitse pitää appia auki tietääksesi mitä tapahtuu. **Agenttisi ja appisi voivat lähettää sinulle ilmoituksia ja muistutuksia** — agentti sai tehtävän valmiiksi, appilla on jotain odottamassa, määräaika lähestyy.

**Missä ne tavoittavat sinut.**

- **Kello** AIMEATin sisällä — juokseva lista lukemattomien määrällä, kukin vie suoraan oikeaan paikkaan.
- **Selainpush** — samat hälytykset työnnettynä **puhelimeesi tai työpöydällesi** selaimen kautta, joten saat ne silloinkin kun AIMEAT ei ole auki. Tilaat laitteesi kerran.
- **Sähköposti** — käytössä tärkeille järjestelmäviesteille (kirjautumislinkit, turvallisuus, kutsut) ja, jos kytket sen päälle, ilmoitussähköposteille tyypeittäin.

Jokainen ilmoitus on merkitty **kuka sen lähetti** (mikä agentti tai appi), joten tiedät aina lähteen, ja se linkittää suoraan siihen mistä on kyse.

**Sinä päätät.** Kaikki tämä on kohdassa **Profiili → Notifications**: kytke selainpush päälle tai pois laitekohtaisesti, lähetä itsellesi testi, ja valitse mitkä ilmoitussähköpostit haluat. Mikään ei piippaa ilman lupaasi — ja voit muuttaa asetuksia milloin tahansa.

**Vaiheet:**
1. Agentit ja appit voivat lähettää sinulle ilmoituksia ja muistutuksia
2. Kello AIMEATissa + selainpush puhelimeesi tai työpöydällesi
3. Sähköposti tärkeille järjestelmäviesteille (jos otat sen käyttöön)
4. Hallitset kaikkea kohdassa Profiili → Notifications

**MCP-tapa:** Sano AI:llesi: ”Näytä viimeisimmät ilmoitukseni ja mistä kukin kertoo.”


## L8: Case-tarinat — flow'lla rakennettu

Oikeita buildejä, tarkat promptit ja rehelliset ajat. Jokainen tarina näyttää, miten research-first-flow (tutki → raamit → ehdotus → toteutus → viimeistely) vie ideasta julkaistuksi appiksi — ja mitä matkalla opittiin. Kopioi sama prompti ja tee perässä.

**Käyttäjälle:** Näet, mitä yhdellä promptilla oikeasti syntyy, ja saat saman promptin kopioitavaksi omaan AI-chattiisi.
**Kehittäjälle:** Opit flow'n vaiheet oikeasta buildista: mitä agentti tutki, millaiset raamit se ehdotti, miten iteraatiot etenivät ja mitä pitfalleja kirjattiin talteen seuraavaa buildia varten.
**Kaikille:** Todisteet ilman teknistä kieltä: idea illalla, pelattava peli saman istunnon aikana.

### Tower Tetris: yhdestä promptista live-moninpeliksi

**Mitä syntyi:** Tower Tetris — 3D-moninpeli, jossa jokainen selvitetty rivi kasvattaa kaikkien pelaajien yhteistä tornia. Realtime-huoneet, pysyvä yhteinen torni (T3-extension), tyylitelty peli-UI ja FI/EN-kielet. Pelaa: tetris3d.apps.aimeat.io.

**Miten se tehtiin:** Claude Code -koodausagentti, MCP-yhteys AIMEATiin, ja tämä yksi aloitusprompti:

`Build me a tower tetris game on AIMEAT. You have aimeat_* MCP tools — follow the research-first flow: load the skill node:aimeat-app-builder and call aimeat_appdev_overview first.`

Agentti tutki ensin, mitä nodella jo on (kirjastopaketit todistuksineen, templatet, pitfall-rekisteri), ehdotti raamit, ja rakensi pelin rungon — realtime-moninpeli mukaan lukien — **noin 40 minuutissa**. Sen jälkeen kolme iteraatiokierrosta samassa istunnossa, esimerkiksi tämä:

`lets do the small T3 extension and add it as v0.2 to get the always-on shared tower! also lets make this game look more like a game and stylish one, please. websearch design trends for this kind of game — colorful, happy, energic — and lets update the UI to match that vibe. also I want to have this in english and finnish languages.`

**Rehellisyyden nimissä:** runko syntyi 40 minuutissa, viimeistely (pysyvä torni, tyylit, kielet, purkumekaniikat) iteraatioilla sen päälle — ja juuri niin flow on tarkoitettu toimimaan: raamit ensin, hionta rakentaessa.

**Miksi tämä ei ollut tuuria:** flow'n research-vaihe antoi agentille valmiiksi realtime-pitfallit (rekisteröi käsittelijät ennen yhteyttä, niputa viestit tickeittäin, huoneen uudelleenluonti), oikeat kirjastopaketit ja T1→T3-päätöspuun. Lopuksi agentti kirjasi omat oppinsa takaisin tietokantaan — seuraava buildi alkaa viisaampana.

**Vaiheet:**
1. Tutki: agentti lataa node:aimeat-app-builder-skillin ja kutsuu aimeat_appdev_overview'n — omat appit, kirjastopaketit todistuksineen, templatet ja pitfallit yhdellä kutsulla
2. Raamit ja ehdotus: tier (tässä T1 + realtime-pack, myöhemmin T3), aloituspiste ja kielet — agentti ehdottaa, sinä hyväksyt tai korjaat
3. Rakenna ja julkaise: pelin runko realtime-moninpeleineen syntyi noin 40 minuutissa ja julkaistiin suoraan nodelle MCP:llä
4. Iteroi: v0.2 toi T3-extensionin (pysyvä yhteinen torni), tyylit haettiin design-trendeistä ja peli sai FI/EN-kielet — kolme kierrosta samassa istunnossa
5. Viimeistele: agentti kirjasi oppinsa (pitfallit ja template-ehdotuksen) takaisin tietokantaan — seuraava buildi alkaa viisaampana

**MCP-tapa:** Sano AI:llesi: "Build me [sovellusideasi] on AIMEAT. You have aimeat_* MCP tools — follow the research-first flow: load the skill node:aimeat-app-builder and call aimeat_appdev_overview first."

### Demot

- **Pelaa Tower Tetristä**: Tarinan lopputulos livenä: 3D-moninpeli, jossa rivisi kasvattavat kaikkien yhteistä tornia. Rakennettu yhdellä promptilla ja kolmella iteraatiolla. (https://tetris3d.apps.aimeat.io/)
- **Research-first-flow-prompti**: Sama flow, jota tarinassa käytettiin — liitä tämä kerran MCP-yhteydelliseen koodausagenttiisi (Claude Code, OpenHands), niin jokainen AIMEAT-buildi alkaa tutkimalla, mitä on jo olemassa. (https://aimeat.io/v1/prompts/appdev-flow?format=txt)


## B0: Arvopyramidi — missä olet, minne menet

Yksi kuva siitä, miten AIMEAT rakentuu ja miten organisaatio kasvaa sen päällä: lue alhaalta ylös, ensikosketuksesta yhdistettyyn riippumattomuuteen. Tämä on kartta, jonka päälle business-tasot B1–B4 rakentuvat.

**Käyttäjälle:** Näet koko matkan yhdellä silmäyksellä — ja missä oma käyttösi on nyt.
**Kehittäjälle:** Näet, miten arkkitehtuuri (organismit, workspacet, recordit, appit, agentit, ledger) pinoutuu asiakasarvoksi.
**Kaikille:** Ymmärrät tasot, joiden läpi yritys etenee AIMEATin kanssa — aloittamisesta oman datan ja AI:n johtamiseen.

### Aloitus

Tulet mukaan sillä AI:lla, jota jo käytät — ChatGPT, Claude, Gemini tai muu. AIMEAT liittyy siihen sen sijaan että korvaisi sen: AI-chattisi juttelee AIMEATille suoraan MCP:n kautta, tai käytät valmista appia tai playbookia. Lähtökohta on kohdata siellä, missä jo olet.

**Vaiheet:**
1. Ihmiset + AI, jota jo käytät
2. Kohtaavat AIMEATin MCP:n, valmisappien ja playbookien kautta
3. Ei migraatiota, ei uutta työkalua opeteltavaksi

### Järjestäydy

Annat maailmallesi rakenteen: organismit ovat ylimmän tason tiloja, workspacet elävät niiden sisällä, ja recordit, dokumentit ja workspace-appit niiden sisällä. Ihmiset ja AI-agentit liittyvät jäseniksi määritellyin oikeuksin. Tämä on orastava vaihe — asiat alkavat muotoutua.

**Vaiheet:**
1. Organismit → workspacet → recordit, dokumentit, workspace-appit
2. Ihmiset ja AI-agentit liittyvät jäseniksi
3. Kypsyys: orastava

### Tee yhdessä, kehity ja automatisoi

Ihmiset ja AI-agentit työskentelevät rinnakkain samassa datassa — datassa, jonka sinä omistat. Rutiinityö alkaa automatisoitua, raaka tieto jalostuu käyttökelpoiseksi, ja päätökset tehdään sen päälle. Tämä on kehittyvä vaihe: rakenne muuttuu arjen työtavaksi.

**Vaiheet:**
1. AI + ihmiset työskentelevät samassa datassa, jonka omistat
2. Rutiini automatisoituu; tieto jalostuu; päätökset syntyvät
3. Kypsyys: kehittyvä

### Datan omistajuus ja arvo

Nyt arvo näkyy: saavutetut tulokset, säästetty työ. Kaikki on läpinäkyvää ja jäljitettävää — mittaava ledger kirjaa, mitä käytettiin ja mitä se tuotti, joten AI:n käyttö on näkyvää eikä piilossa. Ja data pysyy sinun. Tämä on muuttava vaihe, ja tästä alkaa asiakasarvon tikapuu.

**Vaiheet:**
1. Tulokset, säästöt, arvo — näkyviksi tehtyinä
2. Läpinäkyvää ja jäljitettävää, mitattuna ledgerillä
3. Kypsyys: muuttava

### Tavoite — strategia ja johtaminen

Omistajuuden mukana tulevat hallinta ja mitattavuus — voit johtaa strategialla, koska data ja AI ovat aidosti sinun, eivät vuokralla jonkun toisen seinien takana. Hallinto ei ole erillinen tuote, jonka pulttaat kiinni; se seuraa luonnostaan siitä, että omistat sen, mitä ajat.

**Vaiheet:**
1. Omistajuus käytännössä: hallinta + mitattavuus
2. Johdat strategialla dataa ja AI:ta, jotka oikeasti omistat
3. Hallinto seuraa omistajuudesta, ei ole erillinen tuote

### Tulos — yhdistetty, ei riippuvainen

Tulos huipulla: yhdistettävyys yhdessä riippumattomuuden kanssa. Olet yhteydessä kumppaneihin, asiakkaisiin ja heidän AI:hinsa — voit vaihtaa tietoa ja toimintaa rajojen yli — ilman että jäät lukkoon tai riippuvaiseksi yhdestäkään toimittajasta. Yhdistetty, ei riippuvainen.

**Vaiheet:**
1. Yhdistettävyys + riippumattomuus
2. Heidän liiketoimintansa ja AI:nsa + sinun — kumppaneina
3. Asiakkaasi, kumppanisi ja heidän käyttäjänsä, kaikki tavoitettavissa


## F: Nodet ja federaatio — yhdestä koneesta verkostoksi

Sama node-ohjelmisto pyörii kaikkialla — läppärillä, osaston palvelimella, yrityksen rungossa. Federaatio kytkee nodet yhteen niin, että tunnukset toimivat niiden yli mutta jokainen node pitää oman datansa. Viisi kuvaa, yhdestä nodesta yritysten väliseen verkostoon.

**Käyttäjälle:** Ymmärrät, missä tilisi asuu (kotinode) ja miksi sama kirjautuminen toimii muuallakin.
**Kehittäjälle:** Näet käyttöönottotopologiat (yksi node, osastot, henkilökohtaiset, yritysten välinen) ja mihin kirjautumispalvelut ja IAM-kerrokset asettuvat.
**Kaikille:** Näet, miten yritys kasvaa yhdestä yhteisestä nodesta osastoihin, privaattinodeihin ja kumppaniverkostoihin — omistajuutta menettämättä.

### Kuvakierros

1. **Koko kuva: firmat, nodet, federaatio ja markkina** Yritykset pitävät sisällään nodeja, ja node pitää sisällään käyttäjät, appit ja agentit sekä muistin. Federaatio kytkee nodet yhteen yrityksen sisällä ja yritysten välillä, ja ympärillä elää ekosysteemi: ihmisiä, agentteja ja AI-chatteja. Keskellä EXCHANGE-markkina, jossa appin tarve muuttuu sopimukseksi ja sopimus mitatuiksi kutsuiksi: dataa, työkaluja ja agenttityötä ostetaan ja myydään.

### Yksi node — koko porukka yhdellä koneella

Yksinkertaisin kokoonpano: yksi node, kaikki samassa. Node on keskellä — siellä ovat tilit, data ja app-catalog. **Käyttäjät** kiinnittyvät nodeen omilla identiteeteillään (GHII). **Appit** tulevat nodesta ja kytkeytyvät käyttäjiin, jotka niitä käyttävät. **Agentit** ovat käyttäjien valtuuttamia — jokainen agentti kuuluu ihmiselle — ja ne tekevät työnsä samojen appien ja saman datan kautta. Yksi kone, selkeä omistajuus: jokaisella datalla on omistaja ja jokaisen agentin takana on ihminen. Näin aimeat.io itse toimii, ja sama ohjelmisto pyörii myös läppärillä.

**Vaiheet:**
1. Node on keskellä: käyttäjät kiinnittyvät siihen
2. Appit lähtevät nodesta ja palvelevat käyttäjiä
3. Agentit kuuluvat käyttäjille ja työskentelevät appien kanssa

### Osastonodet — yksi yritys, federoituna

Kun yritys kasvaa, osastot saavat omat nodensa — jokaisella täsmälleen sama rakenne kuin yhden noden kokoonpanossa: omat käyttäjät, appit, agentit ja data. **Federaatio** kytkee nodet toisiinsa: jokainen yhteys on hyväksyttyjen vertaisten välinen ja jokainen federaatioviesti on kryptografisesti allekirjoitettu, joten node luottaa vain siihen, mihin se on päättänyt luottaa. Tärkein hyöty on identiteetti: työntekijän tili asuu oman osaston nodella (**kotinode**), mutta sama kirjautuminen toimii koko federoidussa yrityksessä. Data ei valu hiljaa minnekään — jokainen osasto pitää omansa ja jakaa harkiten.

**Vaiheet:**
1. Jokaisella osastolla on oma node samalla rakenteella
2. Federaatio kytkee nodet toisiinsa
3. Yksi tunnus toimii koko yrityksessä — kotinode pysyy osaston omana

### Omat lokaalinodet — privaatti työ, kytkettynä ylöspäin

Sama node-ohjelmisto pyörii myös työntekijän omalla koneella. **Omalla lokaalinodella** saat täyden yhdistelmän — omat käyttäjät (sinä), omat appit, omat agentit — privaattiin työhön, joka ei koskaan poistu koneeltasi. Kun haluat tehdä yhteistyötä, lokaalinode federoituu osaston nodeen, ja osaston node yrityksen nodeen: ketju **lokaali → osasto → yritys**, jossa jokainen taso omistaa oman datansa ja valitsee, mitä virtaa ylöspäin. Arvopyramidin kruunu pätee joka lenkissä: yhdistetty, ei riippuvainen.

**Vaiheet:**
1. Työntekijällä voi olla oma lokaalinode — sama rakenne, oma kone
2. Privaattijutut pysyvät paikallisina; node federoituu osaston nodeen
3. Ketju jatkuu: lokaali → osasto → yritys
4. Yhdistetty, ei riippuvainen — joka tasolla

### Yritysten välillä — kumppaniverkosto nodeista

Sama kaava skaalautuu yritysrajojen yli. Jokainen yritys pyörittää omaa nodeaan (tai omaa sisäistä node-verkkoaan) omine käyttäjineen, sovelluksineen ja agentteineen. **Yritysten välinen federaatio** kytkee ne vertaisiksi: kumppanit tavoittavat toisensa, identiteetit tunnistetaan rajan yli ja agentit voivat tehdä yhteisiä töitä — samalla kun jokaisen yrityksen data pysyy sen omassa infrassa ja omistuksessa. Tämä on arvopyramidin kruunun päätepiste: heidän liiketoimintansa ja AI:nsa + sinun — kumppaneina, yhdistettyinä, ei riippuvaisina.

**Vaiheet:**
1. Jokainen yritys pyörittää omaa node-maailmaansa: käyttäjät, appit, agentit
2. Federaatio linkittää yritykset hyväksyttyinä, allekirjoitettuina vertaisina
3. Kumppanit vaihtavat tietoa ja toimintaa — kukaan ei luovuta dataansa

### Kirjautuminen ja IAM — kolme hallinnan kerrosta

Identiteetissä on kolme kerrosta, ja ne täydentävät toisiaan kilpailemisen sijaan.

1. **Kirjautumispalvelut** — node hyväksyy ulkoiset identiteetintarjoajat geneerisen OIDC-rekisterin kautta: Casdoor, Microsoft Entra ID, Google ja muut OpenID Connect -tarjoajat kytkeytyvät konfiguraatiolla. Yritys pitää nykyisen identiteetinhallintansa; työntekijät kirjautuvat tunnuksilla, jotka heillä jo on.
2. **Noden oma IAM** — kirjauduit millä tahansa, node valvoo omaa pääsymalliaan: omistaja/agentti/appi-roolit, oikeus-scopet, peruttavat luvat ja workspace-kohtaiset oikeudet. Ulkoinen kirjautuminen ei koskaan ohita tätä — se vastaa vain kysymykseen ”kuka olet”, ei koskaan ”mitä saat tehdä”.
3. **Appikohtainen IAM** — sovellus voi määritellä oman yksityiskohtaisen pääsymallinsa päälle (esimerkiksi käyttäjätasot ja ryhmät aimeat-iam-kaavalla: tämän akatemian business-tasot toimivat juuri niin). Appi päättää tasonsa; node valvoo silti alempaa kerrosta.

Eli: tuo oma kirjautumisesi, node vartioi dataa, ja jokainen appi voi olla juuri niin hienojakoinen kuin sen käyttötapaus vaatii.

**Vaiheet:**
1. Kirjaudu sillä, mikä jo on: Casdoor, Microsoft Entra ID, Google …
2. Nodella on oma IAM: roolit, scopet, luvat, workspace-oikeudet
3. Appi voi määritellä oman yksityiskohtaisen IAM:n päälle


## B1: EE — My Company: yritys AIMEATissa

Yritystaso: My Company -kokonaisuus, KYB-varmennus, maksukanavat (PSP) ja se, mitä yritys voi alustalla myydä.

**Käyttäjälle:** Näet, miten yrityksesi identiteetti, varmennus ja rahaliikenne asettuvat alustalle.
**Kehittäjälle:** Opit org-tason työkalut: KYB, PSP-tunnisteet ja myytävien kohteiden manifestit.
**Kaikille:** Ymmärrät, miksi myyminen vaatii varmennetun yrityksen ja oman maksukanavan.

### My Company — yrityksesi AIMEATissa

Enterprise-taso (EE) tuo alustalle **yrityksen**: My Company -kokonaisuuden, jossa organisaatiolla on oma identiteetti, jäsenet, agentit ja rahaliikenne — samoilla periaatteilla kuin yksityishenkilöllä, mutta yrityksen nimissä.

Myynnin portti on **KYB (Know Your Business)**: ennen kuin yritys myy alustalla, se varmentaa itsensä — kuka olette, mikä y-tunnus, kuka edustaa. Vastaavasti kaupankäynnissä **KYC (Know Your Customer)** pitää huolen siitä, että tiedät kenelle myyt. Varmennus ja maksukanava (seuraava oppitunti) tekevät yrityksestä uskottavan myyjän: ostaja — ihminen tai agentti — näkee, että takana on varmennettu toimija.

Sama läpinäkyvyysperiaate kuin kaikessa muussakin AIMEATissa: jokainen myynti, osto ja valtuutus on jäljitettävissä, ja luvat ovat peruttavissa.

**Vaiheet:**
1. Perusta yrityksen organisaatio (My Company)
2. Varmenna yritys: KYB (y-tunnus, edustajat)
3. Kytke maksukanava (PSP) — seuraava oppitunti
4. Ala myydä: agenttien offerit, appien työkalut, appit

**MCP-tapa:** Pyydä AI:ta: ”Näytä organisaationi KYB-tila ja mitä varmennukseen vielä puuttuu.”

### Maksukanavat (PSP) — raha suoraan sinulle

AIMEATissa on kaksi mittaria (L6): morselit (käyttömittari) ja **oikea raha** (EUR/USD). Raha liikkuu maksupalveluntarjoajan (PSP, Payment Service Provider) kautta **suoraan myyjälle** — AIMEAT ei ole pankki eikä välikäsi.

Käytännössä: yritys (tai yksityinen myyjä) tallettaa omat PSP-tunnisteensa alustalle, ja sen jälkeen sen hinnoitellut kohteet — agenttien offerit, appien työkalukutsut — voivat ottaa vastaan rahamaksuja checkoutin kautta. Rahahinnat annetaan mikroyksiköin (1 EUR = 1 000 000), joten pienetkin kertakäyttöhinnat (esim. 0,002 €/kutsu) toimivat. Morselihinnoittelu toimii ilman PSP:täkin — se on kevyt tapa aloittaa.

Koska maksajana voi olla myös **agentti tai AI**, maksukanava on rakennettu koneiden käytettäväksi: checkout on API, hinnat ovat manifesteissa ja ostos joko ajautuu heti (kyvykkyyteen sidottu työkalu) tai muuttuu tehtäväksi myyjän agentille.

**Vaiheet:**
1. Aloita morseleilla — ei vaadi PSP:tä
2. Tallenna PSP-tunnisteet, kun haluat rahamaksut
3. Hinnoittele mikroyksiköin — pienetkin kertakäyttöhinnat toimivat
4. Raha kulkee checkoutista suoraan myyjälle

**MCP-tapa:** Pyydä AI:ta: ”Näytä maksukanavani tila (PSP) — ja jos se puuttuu, kerro miten tunnisteet asetetaan.”

### Mitä yritys voi myydä

Alustalla on kolme myytävää kohdetta, ja kaikki kolme ovat jo tuotannossa:

- **Agenttien palvelut (offerit)** — agentti julkaisee offerin, hinnoittelee sen (morseleita ja/tai rahaa) ja toinen omistaja voi kutsua sitä. Workflow-yhteensopiva offer kelpaa myös osaksi ostajan automaatiota. (Perusteet: L3 Offerings.)
- **Appien työkalukutsut** — appi julkaisee työkalumanifestin hintoineen: kyvykkyyteen sidottu työkalu ajautuu heti, muu muuttuu tehtäväksi agentillesi. Elävä esimerkki: PRH Yrityshaku — haut 2 morselia/kutsu, AI-tiivistelmä 10 morselia johdannaistuotteena. (Perusteet: L4 ”Appisi agenteille”.)
- **Appit ja johdannaiset** — appi itsessään palveluna sekä datastasi jalostetut tuotteet, joita agenttisi tuottavat tilauksesta.

Myyjän muistilista: KYB kuntoon, maksukanava valittuna (morselit ja/tai PSP), hinnat manifesteissa — ja ostajina ovat ihmisten lisäksi agentit, jotka löytävät hinnoitellut kohteet julkisesta commerce-feedistä.

**MCP-tapa:** Pyydä AI:ta: ”Listaa myytävät kohteeni — offerit, appien työkalut ja hinnat — ja ehdota, mitä hinnoittelisin seuraavaksi.”


## B2: API:t AI-natiiveiksi

Kiihdytä oma tai tuotteesi API sellaiseksi, että agentit ja AI:t löytävät sen, osaavat käyttää sitä ja voivat maksaa käytöstä — kertakäytöstä laskuttaen tai muilla malleilla. Elävä esimerkki: PRH Yrityshaku; kiihdytin: TURBO.

**Käyttäjälle:** Näet, miltä AI-natiivi API näyttää käyttäjälle ja agentille.
**Kehittäjälle:** Opit reseptin: appi + sidottu skilli + myytävät työkalukutsut API:n ympärille.
**Kaikille:** Ymmärrät, miten olemassa oleva järjestelmä alkaa palvella AI-aikakautta ja tuottaa.

### AI-natiivi API — PRH Yrityshaku esimerkkinä

Tavallinen API palvelee koodia. **AI-natiivi API** palvelee myös agentteja ja AI-chatteja — se on löydettävissä, opetettavissa ja ostettavissa. Resepti on kolmiosainen:

1. **Appi API:n ympärille** — selaimessa toimiva käyttöliittymä ihmisille, ja samalla API:n koti alustalla.
2. **Sidottu skilli** — opettaa mille tahansa agentille tai AI-chatille, miten juuri tätä API:a kutsutaan (MCP ja REST).
3. **Myytävät työkalukutsut** — työkalumanifesti hintoineen: agentti voi ostaa kutsun ja saada tuloksen heti, tai tilata jalostetun tuotteen tehtävänä.

Elävä esimerkki: **PRH Yrityshaku** (prh.apps.aimeat.io) — Suomen avoin yritysdata AI-natiivina: haut suoraan AI-chatista, 2 morselia/kutsu, ja `companyBrief`-tiivistelmä agentin tuottamana johdannaisena. Sama resepti sopii MIHIN TAHANSA API:in: teidän tuotteenne rajapinta, sisäinen data-API tai kumppanirajapinta.

**Vaiheet:**
1. Valitse API (oma tuote, sisäinen data, kumppanirajapinta)
2. Rakenna appi + sido skilli — agentit oppivat käytön
3. Julkaise työkalumanifesti hintoineen
4. Agentit löytävät, käyttävät ja maksavat

**MCP-tapa:** Kokeile itse: kytke chattisi MCP:llä (L0) ja sano: ”Hae PRH Yrityshaulla [yrityksen nimi] ja kerro perustiedot.”

### TURBO — kiihdytin, jolla se tehdään

**TURBO** (turbo.apps.aimeat.io) on kiihdytin, jolla API nativisoidaan: se tuottaa API:n ympärille edellisen oppitunnin reseptin — appin, agenteille tarkoitetun skillin ja myytävien työkalukutsujen manifestin — järjestelmällisesti ja nopeasti. PRH Yrityshaku on rakennettu juuri sillä.

TURBO on **AIMEAT BROTHERSin IPR:ää ja omaisuutta**: emme myy työkalua, vaan **palvelun** — teidän API:nne AI-nativisoinnin yhdessä kanssanne. Te tunnette rajapintanne ja liiketoimintanne; me tuomme kiihdyttimen, alustan ja mallin, jolla lopputulos on heti agenttien löydettävissä, käytettävissä ja laskutettavissa.

Lopputulos on teidän: appi julkaistaan teidän nimissänne, hinnat ovat teidän, ja raha kulkee teidän maksukanavanne kautta suoraan teille.

**MCP-tapa:** Sovi esittely: käydään teidän API:nne läpi ja näytetään, miltä se näyttäisi AI-natiivina — PRH-esimerkin rinnalla.

### Laskutus käytöstä — mallit

AI-natiivi API voi laskuttaa monella mallilla, ja maksajana voi olla ihminen, agentti tai AI:

| Malli | Miten toimii | Sopii |
|---|---|---|
| Kertakäyttö (per-call) | Hinta per kutsu — morseleita tai rahaa mikroyksiköin | Haut, tarkistukset, pienet operaatiot |
| Per tulos (per-result) | Hinta valmiista tuloksesta | Jalostetut tuotteet, raportit |
| Tehtävä agentille | Ostos muuttuu tehtäväksi myyjän agentille | Johdannaistuotteet (esim. AI-tiivistelmä) |
| Jatkuva (subscription) | Toistuva oikeus käyttöön | Vakiokumppanit, integraatiot |

Periaatteet pysyvät samoina kuin muualla alustalla: omalle omistajalle käyttö on ilmaista, hinnoitellut kohteet listautuvat commerce-feediin, morselit toimivat ilman PSP:tä ja raha vaatii myyjän PSP:n — ja kulkee suoraan myyjälle. PRH Yrityshaussa näet kaksi mallia rinnakkain: 2 morselin välittömät haut ja 10 morselin `companyBrief` tehtävänä.

**MCP-tapa:** Pyydä AI:ta: ”Ehdota API:lleni hinnoittelumalli: mitkä kutsut per-call-hintaan, mikä kannattaa myydä jalosteena.”

### Demot

- **PRH Yrityshaku — AI-natiivi API livenä**: Avoin yritysdata AI-natiivina: appi, agenteille sidottu skilli ja myytävät työkalukutsut. Kokeile selaimessa — tai kutsu suoraan AI-chatistasi. (https://prh.apps.aimeat.io/)
- **TURBO — API-kiihdytin**: Kiihdytin, jolla API:t nativisoidaan (AIMEAT BROTHERSin IPR). PRH Yrityshaku on rakennettu tällä — teidän API:nne voi olla seuraava. (https://turbo.apps.aimeat.io/)


## B3: Managed-ympäristöt ja agenttihautomot

Vuokraa heti käyttövalmis agenttiympäristö perusagentteineen — mukana agentti, joka osaa tehdä lisää agentteja ja orkestroida. Tai suljettu, täysin omassa hallussasi oleva ylläpidetty ympäristö, jonka me pidämme ajan tasalla ja monitoroimme.

**Käyttäjälle:** Saat laivaston käyttöön ilman omaa infraprojektia.
**Kehittäjälle:** Ympäristö tulee valmiina: runtime, perusagentit, forge ja ohjaamo.
**Kaikille:** Ymmärrät vaihtoehdot: jaettu hautomo heti vs. oma suljettu ympäristö neuvotellen.

### Agenttihautomo — vuokraa valmis ympäristö

Agenttihautomo on **heti käyttövalmis, vuokrattava ympäristö**: saat pystytettynä runtime-ympäristön ja perusagentit, jotka osaavat tehdä työtä heti — ja mukana on agentti, joka osaa **tehdä lisää agentteja** ja orkestroida niitä tarpeen mukaan (crewaimeat-runtimen forge-malli: agentti, joka rakentaa agentteja).

Mitä saat:
- Ympäristö käytössä heti — ei omaa infraprojektia, ei asennuksia.
- Perusagentit valmiina + forge: laivasto kasvaa kuvailemalla, mitä uuden agentin pitää osata.
- Ohjaamo (AGENCY / aimeat-agency): näet ja ohjaat kaikkea selaimesta tai työpöydältä.
- Me pidämme ympäristön ajan tasalla ja monitoroimme sitä — sinä käytät.

Hautomo on nopein tie kokeilusta tuotantoon: aloita yhdellä rutiinilla, anna forgen kasvattaa laivastoa sitä mukaa kuin tarve kasvaa.

**Vaiheet:**
1. Vuokraa hautomo — ympäristö käyttöön heti
2. Perusagentit + forge valmiina: kuvaile, mitä uuden agentin pitää osata
3. Ohjaa kaikkea AGENCY-ohjaamosta
4. Me päivitämme ja monitoroimme — sinä käytät

**MCP-tapa:** Kysy meiltä hautomoa — ja ympäristön saatuasi sano sen AI:lle: ”Perusta ensimmäinen rutiini: [työ] joka aamu.”

### Suljettu, ylläpidetty ympäristö

Kun jaettu hautomo ei riitä — datan, sääntelyn tai riskinhallinnan takia — vaihtoehto on **oma suljettu ympäristö**: koko järjestelmä täysin teidän hallussanne, teidän rajojenne sisällä.

- **Arvokkaampi ja turvallisempi**: dedikoitu ympäristö, teidän datanne ei jaa mitään kenenkään kanssa.
- **Täysin teidän**: omistus, pääsy ja säännöt ovat teidän. Me emme näe dataanne.
- **Me pidämme sen elossa**: päivitykset, ajantasaisuus, monitorointi ja tuki ovat meidän vastuullamme — järjestelmä ei jää yksin.
- **Federaatio**: autamme kytkemään suljetun ympäristönne muihin nodeihin hallitusti (federaation ydin on identiteetti ja kirjautuminen yli node-rajojen) — yhteistyö kumppaneiden kanssa ilman, että data lähtee käsistänne.

Tämä malli vaatii enemmän yhteistyötä ja siitä sovitaan erikseen — mutta se on täysin mahdollinen ja tarkoitettu juuri niille, joille hallinta on ehdoton vaatimus.

**MCP-tapa:** Sovi keskustelu: käydään läpi vaatimuksenne (data, sääntely, kumppanit) ja mitoitetaan suljettu ympäristö niihin.


## B4: Agent-facing liiketoiminta

Portaalien jälkeinen aika: AI-nativisoidut itsepalvelu- ja kumppaniportaalit, joista portaalisuus katoaa — osapuolten välille syntyy agenttien hoitama automaatio, ajantasainen tiedonkulku ja nopea vaste.

**Käyttäjälle:** Asiakkaasi ja kumppanisi asioivat AI:nsa kautta — ilman lomakeviidakkoa.
**Kehittäjälle:** Rakennat rajapinnat, joita molempien osapuolten agentit käyttävät.
**Kaikille:** Ymmärrät, miksi tiedottaminen, päivitykset ja palaute paranevat, kun agentit välittävät ne.

### Portaalien jälkeen — agent-facing itsepalvelu ja kumppanuudet

Perinteinen itsepalvelu- tai kumppaniportaali on paikka, jonne ihminen kirjautuu täyttämään lomakkeita. **Agent-facing liiketoiminnassa portaalisuus katoaa**: sama palvelu on olemassa, mutta sitä käyttävät molempien osapuolten AI:t ja agentit — ihminen pyytää omalta AI:ltaan, ja asiat tapahtuvat.

Mitä osapuolten väliin syntyy, kun agentit hoitavat liikenteen:

- **Tiedottaminen paranee** — tieto kulkee agentilta agentille heti, ei uutiskirjeen tahdissa.
- **Ajantasaisuus** — kumppanisi AI tietää tuotteesi tilan, hinnat ja muutokset samalla hetkellä kun ne julkaistaan.
- **Päivitykset perille** — muutokset eivät jää portaaliin odottamaan, vaan agentti vie ne kumppanin järjestelmään asti.
- **Jalostettu palaute** — palaute ei tule raakana lomakevirtana, vaan agentti luokittelee, tiivistää ja reitittää sen valmiiksi (L5:n kerää → jalosta → näytä -kuvio).
- **Nopea vaste** — kysymykseen vastaa ensin agentti, heti; ihminen astuu mukaan vain hyväksyntäkohdissa.

Rakennuspalikat ovat tämän akatemian aiemmat tasot: AI-natiivit API:t (B2), agenttien offerit ja työnkulut (L3/L5), maksukanavat (B1) — agent-facing portaali on niiden yhdistelmä teidän asiakas- ja kumppaniprosesseissanne.

**MCP-tapa:** Pyydä AI:ta: ”Käy läpi asiakas- ja kumppaniprosessimme ja ehdota, mitkä niistä muuttuisivat agent-facing-malliin ensimmäisinä.”


## B5: Agenttihautomo — oma agenttihautomosi

Agenttihautomo tuotteistettuna: nostat pystyyn instanssin, ajat monta agenttia rinnakkain, kuoritat uusia malleista, jaat niitä ja hallinnoit niitä resursseina. Käytä sitä hostattuna osoitteessa agenttihautomo.aimeat.io — tai teetä siitä yrityksesi oma sisäinen palvelu, jossa omistat kaiken infran ja datan.

**Käyttäjälle:** Aja tiimillinen agentteja ilman palvelinprojektia — kuorita lisää kun tarvitset.
**Kehittäjälle:** Saat käyttövalmiin instanssin (10/50/150 agenttia), valmiit mallit ja päivittäiset varmuuskopiot — kytkettynä omaan AIMEAT-nodeesi omilla avaimillasi.
**Kaikille:** Ymmärrät kaksi tapaa saada hautomo: hostattuna tilauksena tai rakennettuna oman yrityksesi sisään niin, että omistat kaiken.

### Hostattu hautomo — agentit rinnakkain minuuteissa

**Agenttihautomo** (agenttihautomo.aimeat.io) on AIMEATin agenttihautomo (L3 / B3) **tuotteistettuna**: hostattu instanssi, jossa monta agenttia ajaa rinnakkain, ja ensimmäinen kuoriutuu minuuteissa — ei asennuksia, ei palvelinten hallintaa, ei agenttikohtaisia maksuja.

Mitä saat:
- **Sinulle mitoitettu instanssi** — Nest (10 agenttia · 19 €/kk), Flock (50 · 49 €/kk) tai Swarm (150 · 99 €/kk); yksi kiinteä kuukausihinta, ei per agentti.
- **Aidosti sinun** — yksityinen, dedikoitu instanssi kytkettynä omaan AIMEAT-nodeesi omilla avaimillasi, ja voit tuoda omat malliavaimesi.
- **Kuoritus malleista** — valmiit agenttimallit tai omasi, ja päivittäiset varmuuskopiot pitävät ne turvassa.
- **Kytketty AIMEATiin** — viestintä, muisti ja tehtävät toimivat verkon yli heti ensimmäisestä minuutista.

Kaikki mitä tämä akatemia opetti — agentit (L1/L3), skillit, offerit, työnkulut — toimii hautomon sisällä. Se on nopein tie ”yhdestä agentista chatissa” toimivaksi laivastoksi.

**Vaiheet:**
1. Valitse paketti — Nest 10, Flock 50 tai Swarm 150 agenttia
2. Kuorita agentteja malleista tai luo omat
3. Kytke omaan AIMEAT-nodeesi ja käynnistä

**MCP-tapa:** Kokeile: avaa agenttihautomo.aimeat.io, valitse paketti ja kuorita ensimmäinen agenttisi — se kytkeytyy AIMEAT-nodeesi minuuteissa.

### Aja se yrityksesi sisällä — omista infra ja data

Sama hautomo voidaan toimittaa yrityksesi **omaksi sisäiseksi palveluksi** — silloin kun haluat omistaa kaiken infran ja datan etkä vuokrata paikkaa jaetusta tuotteesta.

Mitä se tarkoittaa:
- **Sinun infrasi, sinun datasi** — hautomo ajaa rajojesi sisällä (ks. B3:n suljettu, ylläpidetty ympäristö); mitään ei jaeta kenenkään kanssa.
- **Luo ja jaa agentteja** — kuorita uusia agentteja malleista, anna ne tiimeille ja käytä uudelleen läpi yrityksen.
- **Hallinnoi niitä resursseina** — hallintataso ohjaa kapasiteettia: instanssipooli, jonotuslista, provisiointi ja deprovisiointi, tiimikohtaiset instanssit ja terveystarkistukset. Agenteista tulee hallittu resurssi, ei kasa skriptejä.
- **Me rakennamme ja pidämme sen elossa** — AIMEAT BROTHERS rakentaa sen kanssasi ja pitää sen ajan tasalla ja monitoroituna (B3), samalla kun omistus ja hallinta pysyvät täysin sinulla.

Elävä todiste on agenttihautomo.aimeat.io itse: hostattu tuote ja sen operaattorin hallintataso (poolikapasiteetti, jonotuslista, provisiointi/deprovisiointi) ovat täsmälleen sama järjestelmä, jonka yrityksesi voi ajaa sisäisesti.

**MCP-tapa:** Sovi keskustelu: kartoitamme sisäisen hautomosi — kapasiteetin, kuka saa luoda agentteja ja mikä pysyy seiniesi sisällä.

### Demot

- **Agenttihautomo — hostattu agenttihautomo livenä**: Hostatut AI-agentit, ensimmäinen kuoriutuu minuuteissa: yksityiset 10/50/150 agentin instanssit omalla AIMEAT-nodellasi. Sama järjestelmä, joka voidaan rakentaa myös yrityksesi sisään. (https://agenttihautomo.aimeat.io/)


## B6: EXCHANGE: appien datamarkkina

Kaksipuolinen markkinapaikka, jossa appit ostavat tarvitsemansa datan, palvelut ja agenttityön sopimuksella: jokainen kutsu mitataan, budjettikatto suojaa ostajaa ja tarjoaja näkee, kuka dataa käyttää. Settlaa oikealla rahalla (USDC, EURC, Stripe EUR/USD); morselit vain tahdistavat käyttöä.

**Käyttäjälle:** Osta valmis kyvykkyys appiisi minuuteissa: sopimus valtuuttaa kutsut, eikä API-avaimia luovuteta.
**Kehittäjälle:** Listaa datasi, appisi metodi tai agenttisi työ myyntiin julkaistulla I/O-skeemalla ja hinnalla; rajapinta pinnataan versioksi, joten uudet julkaisut eivät riko sopimuksia.
**Kaikille:** Ymmärrät, miten appien välinen datakauppa toimii: tarjonta, tarve, AI-neuvoteltu sopimus ja oikean rahan settlaus.

### Kuvakierros

1. **Askel 1/6: Sinä + AI + datasi = tarjonta** Sinä ohjaat, AI:si listaa datasi tai palvelusi myyntiin I/O-skeemalla ja hinnalla. Muut appit ostavat sen käyttöön omiin sovelluksiinsa.
2. **Askel 2/6: Appi jättää puuttuvat datatarpeensa** Kun rakentamastasi apista puuttuu dataa, AI:si jättää tarpeen markkinalle appin puolesta: tarkalla rajapinnalla, jota appi jää kutsumaan. Tarjoajat vastaavat siihen.
3. **Askel 3/6: AI:t neuvottelevat sopimuksen** Neuvottele omasta MCP-kytketystä AI-chatistasi, tai anna agenttien neuvotella molempien puolesta ja hyväksy vain paras ehdotus. Sopimus on budjettikatettu, eikä API-avaimia luovuteta.
4. **Askel 4/6: Sama mittari, kaksi näkökulmaa** Joka kutsu mitataan. Ostaja seuraa budjettipalkkiaan ja kulutustaan; tarjoaja seuraa, kuka dataa käyttää ja mitä hänelle kertyy.
5. **Askel 5/6: Oikea raha settlaa raiteilla** Kolme raidetta: USDC ja EURC x402:lla sekä Stripe EUR/USD UCP:llä. Morselit vain tahdistavat käyttöä; ne eivät ole valuutta.
6. **Askel 6/6: Uudelleenneuvottelu ja historia** Tarjoaja ja ostaja ovat sopimuksen kahta puolta, ja kumpi tahansa voi ehdottaa uusia ehtoja; agentit auttavat. Ehdotus tulee voimaan vasta hyväksynnästä, ja korvatut sopimukset arkistoituvat.
7. **Palvelussa: markkina** Tältä EXCHANGE näyttää oikeasti: kolme pintaa (datapalvelu, app-työkalu, agenttityö) hintoineen ja elävine maineineen, myös composite-tarjonta, joka kokoaa muita sopimuksia yhdeksi jalostetuksi tuotteeksi.
8. **Palvelussa: tarjonnan tiedot ennen sopimusta** Ennen sopimusta näet kaiken: syöte- ja tulosskeeman, kutsureseptin, käyttöehdot, alkuperän ja hinnoittelun (per kutsu, bundle, tilaus). Avaa sopimus vasta, kun tiedät mitä ostat.
9. **Palvelussa: Sopimukseni ja budjetit** Ostajan valvontanäkymä: jokaisella sopimuksella budjettipalkki, kulutus ja kutsut reaaliajassa. Avaa sopimus hallitaksesi sitä: tauota, ehdota uusia ehtoja tai peru.
10. **Palvelussa: avoimet tarpeet apeittain** Kysyntäpuoli: jokainen tarve kuuluu apille ja julistaa rajapinnan, jota appi jää kutsumaan. Tarjoajana avaat tarpeen, rakennat matchaavan kyvykkyyden ja tarjoat sitä.

### Myy dataa, palveluita ja agenttityötä

EXCHANGEssa on kolme myyntipintaa, ja kaikki kolme toimivat samalla sopimus- ja mittarointimallilla:
- **Data** : extension, joka hakee lähde-API:a; API-avain pysyy salattuna tarjoajan extension-secret-storessa, eikä ostaja koskaan näe sitä.
- **Palvelut** : appisi oma metodi (app-tool, esim. getCompanyBrief) myyntiin muille apeille. Rajapinta pinnataan muuttumattomaksi versioksi, joten voit julkaista uusia app-versioita rikkomatta olemassa olevia sopimuksia.
- **Agenttityö** : asynkroninen tehtävä, jonka agenttisi toimittaa; veloitus tapahtuu vasta toimituksella.

Jokainen tarjonta julkaisee **I/O-skeeman** (mitä ostaja lähettää ja saa takaisin), **hinnan** (per kutsu, bundle tai tilaus) ja **käyttöehdot** (johdannaiset, jälleenmyynti, lähdeviittaus). Tarjoaja-konsolista näet, kuka dataasi käyttää, kuinka paljon ja mitä sinulle kertyy.

**Vaiheet:**
1. Valitse pinta: data, appisi työkalu tai agenttisi työ
2. Julkaise I/O-skeema, hinta ja käyttöehdot, ja listaa tarjonta
3. Seuraa Tarjoaja-konsolista, kuka käyttää ja mitä sinulle kertyy

**MCP-tapa:** Sano AI:llesi: "Haluan myydä dataa/palvelun AIMEAT EXCHANGEssa. Rakenna tarjoaja-extension tai listaa appini työkalu ja julkaise se tarjonnaksi I/O-skeemalla ja hinnalla."

### Osta appillesi, tai jätä tarve jonka joku täyttää

Ostajan polku alkaa kahdella tavalla:
- **Selaa tarjontaa** : avaa tarjonnan tiedot ennen sopimusta: I/O-skeema, kutsuresepti, käyttöehdot, hinnoittelu ja elävä maine (kutsut, kuluttajat, settlaukset).
- **Jätä tarve** : jos sopivaa ei ole, appisi jättää tarpeen, joka on aina appi-sidottu ja julistaa tarkan rajapinnan: mitä appi lähettää ja mitä se odottaa takaisin. Tarjoajat rakentavat tai osoittavat matchaavan kyvykkyyden ja tarjoavat sitä.
- **Tai anna AI:n hoitaa koko homma** : AI voi tehdä tämän täysin itsenäisesti. Se etsii EXCHANGEsta sopivan, ja jos jokin on lähellä muttei täsmää, se ottaa yhteyttä tarjoajaan (joka voi tehdä sopivan version), muokkaa appiasi niin, että rajapinta sopii, tai rakentaa väliin konvertterin, joka muuntaa tarjolla olevan muodon appisi odottamaan muotoon.

**AI neuvottelee puolestasi.** Neuvottele omasta MCP-kytketystä AI-chatistasi, tai anna agenttien hoitaa neuvottelu ja hyväksy vain paras ehdotus. Hyväksyntä luo pysyvän, budjettikatetun sopimuksen: hinta on tarjoajan, sinä valitset vain budjettikaton. Mitään ei veloiteta ennen kuin kutsut, ja sopimus itse valtuuttaa kutsut, joten API-avaimia ei luovuteta.

Sopimus elää: tauota milloin vain, ehdota uusia ehtoja (tulevat voimaan vasta, kun vastapuoli hyväksyy) tai peru lopullisesti. Korvatut sopimukset jäävät näkyviin historiaan.

**Vaiheet:**
1. Selaa tarjontaa ja lue tiedot: I/O-skeema, hinta, maine
2. Tai jätä appi-sidottu tarve, tai anna AI:n hoitaa koko matchaus
3. Hyväksy paras ehdotus: budjettikatettu sopimus, ei API-avaimia

**MCP-tapa:** Sano AI:llesi: "Appini tarvitsee dataa X: hoida koko ketju EXCHANGEssa. Etsi sopiva, ja jos jokin on vain lähellä, ota yhteyttä tarjoajaan tai rakenna konvertteri väliin, ja avaa budjettikatettu sopimus."

### Raha ja luottamus: mittarointi, raiteet ja morselit

EXCHANGE ei ole leikkipörssi. Sen talous rakentuu kolmesta kerroksesta:
- **Mittarointi, molemmat valvovat** : joka kutsu vähentää ostajan budjettia. Ostaja näkee kulutuksen, kutsut ja siivun Sopimukseni-näkymässä; tarjoaja näkee Tarjoaja-konsolista, kuka dataa käyttää, kuinka paljon ja mitä settlaa. Sama mittari, kaksi näkökulmaa.
- **Oikean rahan raiteet** : mitattu käyttö settlaa oikealla rahalla kolmella raiteella: USDC ja EURC x402-protokollalla sekä Stripe EUR/USD UCP-maksurajapinnalla. Alusta ottaa pienen, operaattorin asettaman siivun jokaisesta mitatusta kutsusta; loput jäävät tarjoajalle.
- **Morselit tahdistavat, eivät maksa** : morselit ovat sisäinen tahdistusyksikkö, joka rajoittaa käyttöä (kokonaislukuja, ei desimaaleja). Ne eivät ole valuutta: oikea raha liikkuu raiteilla, morselit pitävät käytön hallittuna.

Budjettikatto on ostajan turva: sopimus ei koskaan kuluta yli katon, ja kun katto lähestyy, sen näkee palkista ennen kuin mitään yllättävää tapahtuu.

**Vaiheet:**
1. Ostajana: seuraa budjettipalkkia ja kulutusta Sopimukseni-näkymässä
2. Tarjoajana: seuraa kuluttajia ja settlauksia Tarjoaja-konsolista
3. Muista: raha liikkuu raiteilla, morselit vain tahdistavat

**MCP-tapa:** Sano AI:llesi: "Näytä EXCHANGE-sopimusteni kulutus ja budjetit, ja tarjoajana mitä minulle on kertynyt ja keneltä."

### Sama markkina yrityksen sisällä: ilmaiseksi, mutta näkyvästi

EXCHANGEa ei tarvitse käyttää vain rahaa vastaan.

**Appia rakentaessa: katso ensin markkinalta.** Ennen kuin rakennat integraation itse, katso, onko EXCHANGEssa jo tarjolla se, mitä olet tekemässä: valmis sopimus on nopeampi ja halvempi kuin oma toteutus, ja I/O-skeema kertoo heti, sopiiko se.

**Yrityksen sisällä: nollahinta, täysi näkyvyys.** Tiimit voivat listata datalähteensä tarjonnaksi nollahintaan, ja muut appit sopivat ne käyttöönsä ilman maksuja. Vaikka raha ei liiku, kaikki muu markkinan hyöty säilyy:
- **Sopimukset appien välillä** : näet, mikä appi käyttää mitäkin datalähdettä ja millä ehdoilla.
- **Käyttömäärät** : jokainen kutsu mitataan, joten näet, mitkä datalähteet oikeasti kantavat ja mitkä eivät.
- **Datan muoto** : jokainen tarjonta julkaisee I/O-skeemansa, joten yrityksen dataliikenne dokumentoituu itsestään.

Tämä kartta appien välisistä datavirroista on itsessään arvokasta tietoa: se kertoo, mitkä integraatiot ovat kriittisiä, mihin kannattaa investoida ja missä data jo liikkuu.

**Vaiheet:**
1. Appia rakentaessa: katso ensin, onko EXCHANGEssa jo tarjolla
2. Listaa sisäiset datalähteet nollahintaan: sopimukset ja mittarointi säilyvät
3. Lue karttaa: kuka käyttää, kuinka paljon ja missä muodossa

**MCP-tapa:** Sano AI:llesi: "Listaa tiimimme datalähde EXCHANGEen nollahintaan, ja näytä sitten, mitkä appit käyttävät mitäkin sisäistä lähdettä ja kuinka paljon."

### Demot

- **EXCHANGE livenä: selaa, sovi, mittaa**: Oikea markkinapaikka oikealla datalla: selaa tarjontaa (data, app-työkalut, agenttityö), avaa tarjonnan tiedot I/O-skeemoineen ja katso, miten sopimukset, tarpeet ja mittarointi toimivat käytännössä. (https://exchange.apps.aimeat.io/)


---

# In English

## Welcome — what is AIMEAT?

AIMEAT is an open platform where you and AI do real work together — and you own your data, your money and your AI. This is a free, hands-on tour: just read it, or try it with the AI you already have. You need no account and nothing special to look around.

**For a user:** Let the AI you already use handle real tasks — notes, messages, research, to-dos — and keep all the data yours.
**For a developer:** Connect AI agents, build apps by describing them (not coding), and wire in your own systems — with no vendor lock-in.
**For everyone:** Give a team the same tools, keep ownership and control of the data, and grow from one machine to departments and a partner network.

### How this tour works

A quick orientation before you dive in:

- **Free and hands-on.** You can read everything and try things directly — nothing to buy.
- **Works with any AI.** Two ways to use AIMEAT: ask your own AI chat to do things (over **MCP**), or copy a ready-made prompt into any AI chat (**copy-prompt**). Both are taught here.
- **You need nothing to start.** No account is needed just to look around, and the copy-prompt way works without MCP and without an AIMEAT login.
- **The tour goes in layers.** L0 basics → L6, plus messaging and the business tiers. Pick any layer on the left — you don't have to go in order.

**Don't worry about the jargon.** If “MCP”, “copy-prompt” or “prompt-driven” mean nothing to you yet, that's completely fine — each gets its own lesson in L0 and becomes familiar fast. You don't need to know anything in advance.

When you're ready, open **L0 Basics** — or copy the taster prompt above into your AI right now.

**Steps:**
1. Free and hands-on — read it, or try it directly
2. Two ways: your own AI chat (MCP), or copy-prompt into any AI
3. New words? No need to know them yet — each gets its own lesson
4. Layers L0 → L6, plus messaging and business — jump anywhere

### The words you'll meet

A handful of words come up throughout the tour. Here they are in plain language — come back here whenever a term puzzles you:

| Word | What it means |
|---|---|
| **Organism** | A shared space (like an HQ) for people and agents |
| **Workspace** | A structured space inside an organism |
| **Agent** | An AI you authorize to work for you |
| **App** | A small application that runs inside AIMEAT |
| **Morsel** | A usage meter — not money |
| **MCP** | A direct, AI-assisted link — your own AI chat talks to AIMEAT itself |
| **Copy-prompt** *(prompt-driven)* | The manual way, no MCP needed: you copy an app's ready prompt into any AI chat and paste the answer back — you carry the information between AIMEAT and the AI |

So the two ways differ in one thing: with **MCP** your AI is connected and does it for you; with **copy-prompt** you move the information by hand. Both are free and taught here — don't worry about memorising anything.

**Steps:**
1. Organism = a shared space (like an HQ) for people and agents
2. MCP = a direct link; copy-prompt = you move the info by hand
3. No need to memorise — each gets its own lesson


## L0: Basics

Start here. Connect your AI chat (MCP), learn the copy-prompt fallback and the three identities (GHII/GAII/GEAI), your profile and the app-catalog.

**For a user:** You immediately see how your own AI chat can do work for you on AIMEAT.
**For a developer:** You connect an agent via MCP and grasp the identity model before building anything.
**For everyone:** No technical background needed: copy a ready-made prompt into your AI chat and it guides the rest.

### Slide tour

1. **Three identities** GHII (Global Human Intelligence Identifier) = you — you own everything, including the wallet. GAII (Global AI Identifier) = an agent you authorize, holding a scoped key. GEAI (Global Ecosystem Application Identifier) = an external application in its own area. All billing always flows to you.
2. **The nicest way: your chat on MCP** Two ways to use AIMEAT: over MCP your chat is wired straight to the node — you ask, things happen. The fallback is the copy-prompt, where the prompt and reply travel back and forth by hand — it works with any AI.
3. **The agent asks — you approve** The agent requests access — you approve and hand over a scoped key. An agent is never created without you noticing, and grants can be revoked at any time.
4. **The app-catalog and versions** The app shelf: every publish creates a version (v1 → v3) and history is kept. Fork someone's app as your own base — the lineage stays visible.
5. **Set up MCP, step 1/5 — create an account** Create a free account at aimeat.io — registering takes a minute, and the account is the foundation for everything else.
6. **Set up MCP, step 2/5 — open your AI tool's settings** Open your AI tool's connector or MCP settings. The lesson's table below tells you where they are — and whether your tool supports MCP at all.
7. **Set up MCP, step 3/5 — add the server address** Paste https://aimeat.io/v1/mcp into the connector field. This one address is the heart of the whole connection.
8. **Set up MCP, step 4/5 — approve and pick the scopes** Approve the connection on your profile's Agents tab and pick the scopes — what the AI may do. Grants can be revoked at any time.
9. **Set up MCP, step 5/5 — test the connection** Test it: tell your AI “List my organisms and tell me what you can do on AIMEAT.” When a real answer comes back, the connection works — from here on you get things done by talking.

### Connect your AI chat (MCP) — the key step

The goal of this lesson: **get your own AI chat connected to AIMEAT over MCP**. The nicest way to use AIMEAT (AI Memory Exchange and Action Transfer) is to ask your own AI to do things right in the conversation, and MCP (Model Context Protocol — the open standard that lets AI chats connect to tools) is what makes that possible. The moment the connection works reliably, use it. If your AI tool does not support MCP, that is fine too: you will use the copy-prompt workflow instead (next lesson).

**Which tool supports MCP — and how do I connect?**

| AI tool | MCP support | How to connect |
|---|---|---|
| Claude (claude.ai) | ✅ Easy | Settings → Connectors → Add custom connector → paste `https://aimeat.io/v1/mcp` |
| Claude Code (terminal) | ✅ Easy | `claude mcp add aimeat --transport http https://aimeat.io/v1/mcp` |
| Codex CLI (terminal) | ✅ Easy | `codex mcp add aimeat --url https://aimeat.io/v1/mcp` |
| Grok (grok.com) | ✅ Easy | grok.com/connectors → New Connector → Custom → paste the address |
| ChatGPT (Plus/Pro/Team) | ⚠️ Developer mode | Settings → Connectors → Advanced → enable Developer mode → Create app → paste the address. Enable the app from the + menu in a conversation. Not available on the free tier. |
| VS Code | ✅ Easy | `code --add-mcp '{"name":"aimeat","url":"https://aimeat.io/v1/mcp"}'` |
| Cursor | ✅ Easy | 1-click install on aimeat.io/v1/connect |
| Gemini (gemini.google.com) | ❌ No | The consumer Gemini app does not support custom MCP servers — use the copy-prompt workflow. (Gemini CLI can: `settings.json` → mcpServers.) |
| Microsoft Copilot | ❌ Not directly | Would require a Copilot Studio setup — in practice: use the copy-prompt workflow. |

**Once connected, try these:**
- “List my organisms and tell me what you can do on AIMEAT”
- “Show my profile and morsel balance”
- “Create an organism called My Office with a workspace”
- “Save a note: …” or “Send a message to member …”

**Chat or Claude Code?** A regular chat (claude.ai, grok.com, ChatGPT) is best for everyday use: messages, organisms, workspaces, workflows and using apps. Terminal tools (Claude Code, Codex CLI) can also write code, so building apps and extensions goes best with them — Claude Code can do a bit of everything. The lightest way to start is chat.

The slide tour above shows these same steps as pictures (steps 1–5).

**Steps:**
1. Create an account at aimeat.io (Register)
2. Find your AI tool in the table and open its connector/MCP settings
3. Add the server: https://aimeat.io/v1/mcp
4. Approve the login and pick the scopes on your profile's Agents tab
5. Test: “List my organisms and tell me what you can do on AIMEAT”

**MCP way:** Find your AI tool in the table and add the MCP server at https://aimeat.io/v1/mcp. Once connected, tell your AI: “List my organisms and tell me what you can do on AIMEAT.”

### Copy-prompt — the no-MCP fallback

The prompt-driven workflow is a loop: the app hands over a prompt → the chat returns a **structured** reply → the reply is pasted back into the app, which **validates it and acts on its content**.

The reply isn't free text: the app dictates the shape (JSON, say), checks what you paste back, and does something with it: fills a form, builds a list, opens the right view. It's free (your own AI), safe (you see everything before sending) and works with any AI. The previous answer feeds the next prompt, so work advances as a chain.

**Try it yourself in the panel at the bottom of this page** — it runs exactly this loop for real.

**Steps:**
1. Copy the prompt and answer the AI's two questions
2. The AI returns a strict JSON reply
3. Paste the JSON back into the app's panel
4. The app validates and acts on the content

**MCP way:** If MCP is available you don't need this — just ask your AI directly. This fallback is for those whose AI can't do MCP.

### Three identities: GHII, GAII, GEAI

In the picture: the blue badge = you (GHII), the green badge = your agent (GAII), the amber badge = an ecosystem app (GEAI) — the red strings show that both of the latter attach to you.

AIMEAT has three roles, never conflated:

- **GHII** (Global Human Intelligence Identifier) = you, the human. You own everything: balance, profile, data, trust.
- **GAII** (Global AI Identifier) = an AI agent you authorize. Its own scoped permissions and trust score.
- **GEAI** (Global Ecosystem Application Identifier) = an ecosystem app. An external application connected into its own namespace, consented like an agent.

The human pays; agent and app balances are always 0 (all billing rolls up to the owner).

**Steps:**
1. Owner (GHII) = your account — owns balance and data
2. Agent (GAII) = an authorized AI with scoped rights
3. Eco app (GEAI) = an external app in its own namespace

**MCP way:** Ask your AI: “Who am I on AIMEAT and which agents do I have connected?” — it reads your identity and lists the agents.

### Your profile — your control room and portal

Once you have an account, your **profile is your personal home in AIMEAT** — the one place to manage your own data, settings and permissions, and to see your morsel balance. It is also a **portal**: from here you reach your agents, your apps, your organisms and everything else you use.

Think of it as your **control room**. Agents connect by device auth — they ask, you approve, you pick the scopes. Your memory is private by default, every grant is revocable, and every action is attributable. Nothing happens without your say-so.

**A tip once you find your way around.** The profile has a screen for everything — but the smoothest way to operate AIMEAT is through your own **AI chat over MCP**. Just ask for what you want: “show my agents”, “save this note”, “who messaged me”, “what's my balance”. The screens are always there when you want to click; the chat is usually faster and nicer once you know what AIMEAT can do.

**Steps:**
1. Your profile is your personal control room in AIMEAT
2. Manage your data, settings, permissions and balance here
3. It's also the portal to your agents, apps and organisms
4. Once you know AIMEAT, operate it fastest via your AI chat (MCP)

**MCP way:** Tell your AI: “Show me my profile — my agents, my data visibility and my morsel balance.”

### App-catalog & releases

The app-catalog is AIMEAT's shopping street: it's where you find and open apps — and build your own. “Create new app” lets you describe an app to an AI, which builds it for you. Publishing creates a version; you can update (a new version) or fork others' apps as a starting point. Every app runs inside AIMEAT, so your data stays under your control.

**Steps:**
1. Open the app-catalog on aimeat.io
2. Browse and open a ready app to try
3. “Create new app”: describe your app to an AI
4. Publish → a version; update or fork later

**MCP way:** Ask your AI: “build me an app that does X.” With MCP tools it can publish the app straight to the catalog.

### Demos

- **Start: build your own path**: Diagnosis → a personal playbook. Three questions and you get a copyable checklist + a startup prompt for your AI. (https://aimeat.io/start)
- **Try the app-catalog**: Browse ready apps and open one to try — or hit “Create new app” and describe your own app to an AI. (https://aimeat.io/app-catalog.html)
- **Create an account or sign in**: A free account on aimeat.io. Right after signup you get your first organism and can connect your AI chat (MCP) or use the copy-prompt path. (https://aimeat.io)

### From the community

- **Build your own starting path (/start)** (AIMEAT): A three-question diagnosis that condenses into a personal playbook checklist + a startup prompt for your AI. A good first step before the deeper layers. https://aimeat.io/start


## L1: Agents & Apps — intro

What an agent is, what an app is, how they differ, and how to connect your first one.

**For a user:** You learn to tell apart “an AI that does work” from “a tool you use”.
**For a developer:** You see where an agent fits vs an app — and when to combine them.
**For everyone:** You understand what “connect an agent” or “open an app” means in practice.

### Slide tour

1. **An app is a tool** An app is a browser tool that YOU use. It lives in the app-catalog and touches your data only with your consent.
2. **An agent is a doer** An agent does the work itself and produces finished results — under its own identity (GAII), with the permissions you granted, even while you're away.
3. **The first connection** The connection prompt lives on your profile's Agents tab: the agent requests to join, you approve and grant a scoped permission. The same pattern repeats everywhere: request → approval → scoped permission.
4. **The app catalog — apps you can open** Every app on the node lives here: open one instantly, or browse the community catalogue. One card per app shows its published version and whether it's listed or unlisted.
5. **Connect your first agent** The recommended path installs the AIMEAT connector (device auth), stores the agent token, downloads the skill bundle and exposes AIMEAT as MCP tools — then you paste the Hello Integration steps to make the agent legible.

### What is an agent?

An agent is an AI **you authorize** to work for you on AIMEAT. It has its own identity (GAII), and you decide its permissions — an agent sees and does only what you allow. It can read and write your workspaces, handle tasks and keep working even when you are away. Grants are revocable, and everything is attributable.

**Steps:**
1. An agent = an authorized AI with its own identity
2. You scope its permissions
3. It can work for you continuously

**MCP way:** Tell your AI: “List my agents and tell me what permissions they have.”

### What is an app?

An app is a browser application that lives in the AIMEAT app-catalog and uses your data **with your consent**. The app doesn't own your data: it reads and writes AIMEAT memory, which stays under your control. The difference from an agent: an app is a tool you use — an agent is a doer that works for you. At their best they work together (more on level L5).

**Steps:**
1. An app = a browser application in the app-catalog
2. It uses your data only with your consent
3. An app is a tool — an agent is a doer

**MCP way:** Ask your AI: “List apps in the app-catalog and suggest one for me.”

### Connect your first agent

An agent is always connected with the same safe pattern: **the agent requests — you approve**. Your profile's Agents tab has a ready connection prompt: copy it to the AI you want as your agent. The AI requests to join, you approve the request in your profile and choose which scopes to grant. An agent is never created without you noticing.

**Next: Hello Integration.** After connecting, the agent can run the Hello Integration handshake: it identifies its platform, reports its capabilities and completes a test task — so you and your other agents can see what it can do and how well it integrates with AIMEAT. Often unnecessary for a pure chat AI, but worth it for a working agent. More in L3.

**Steps:**
1. Open the Agents tab in your profile on aimeat.io
2. Copy the connection prompt to the AI you want as an agent
3. Approve the join request and choose scopes
4. The agent appears in the list — revoke anytime
5. Optionally: run Hello Integration to make the agent's capabilities visible (L3)

**MCP way:** Your chat AI (from L0) already works directly over MCP. A separate agent (e.g. a continuously running worker) is connected with the Agents tab's connection prompt.

### Demos

- **Connect an agent in your profile**: Open your profile's Agents tab — it has a ready connection prompt for a new agent. (Requires signing in.) (https://aimeat.io/v1/profile?tab=agents)


## L2: Organisms & workspaces

A slide run: what organisms and workspaces are, records vs. documents, membership and consent — and what the whole ecosystem offers.

**For a user:** You see where your data lives and who can see it.
**For a developer:** You learn the structure: organism → workspace → records/documents, and locked schemas.
**For everyone:** You get the “your own HQ” idea: spaces where you and your AI do the work.

### Slide tour

1. **Organism — a shared HQ** An organism brings people and agents under one roof: membership, roles and shared rules. Everything else is built inside it.
2. **Workspace — a structured space** The organism is the roof over everything; inside it are workspaces for different purposes. Each workspace holds records, documents, its members, the agents working in it, workspace apps, and documents it can share publicly.
3. **Records and documents** Records are structured data with a locked schema — the same shape even when an agent writes them. Documents are markdown pages: guides, plans and notes.
4. **Draft → publish** Drafts are edited freely; publishing creates a version (v1 → v3) and history is kept — you always know what's current.
5. **Membership and consent** You decide who reads and who writes — and every change traces back to its author.
6. **Public sharing** Selected content can be opened to the public — readable without signing in. That's exactly how this Experience Center works.

### Create your first organism

An organism is a shared **“HQ”** — the roof over everything. It has **members** (people and agents) and shared rules, and inside it you create **workspaces** for different purposes.

A workspace is more than a folder — it's a structured space that holds:

- **Records** — structured data with a locked schema (tasks, decisions, contacts).
- **Documents** — markdown pages (guides, plans, notes).
- **Members** — the people who can read and write there.
- **Agents** — the agents working in the workspace (through their owner's grants).
- **Workspace apps** — apps bound to the workspace for its job.
- **Shared documents** — content you choose to open to the public, readable without signing in.

Start small: one organism, one workspace — for notes or a project — and let the structure grow as needed.

**Steps:**
1. Organism = a shared HQ with members (people + agents)
2. Workspace = a structured space inside it
3. A workspace holds records, documents, members, agents, apps & shared docs
4. Start with one: e.g. “My HQ” + notes

**MCP way:** Tell your AI: “Create an organism called My HQ with a workspace for notes.”

### Records and documents

Workspace content comes in two forms:

- **Records** — structured data with a locked schema: tasks, decisions or contacts, say. The schema guarantees every record has the same shape — even when an agent writes it.
- **Documents** — markdown pages: guides, plans, notes.

Both live by the same rhythm: **draft → publish**. Drafts are edited freely; publishing creates a version, and history is kept.

**Steps:**
1. Record = structured data with a locked schema
2. Document = a markdown page
3. Draft → publish → version history

**MCP way:** Tell your AI: “Show me my workspaces' structure — which record and document spaces they have.”

### Knowledge packages — bring your knowledge in

A knowledge package is a **structured knowledge bundle** in your AIMEAT memory: research, an idea, a plan, a guide or a collection, where every entry carries its own visibility. Its point: **bring knowledge out of AI chats** — precisely the ones without MCP (Copilot, Gemini…) — into AIMEAT in structured form, where it persists, stays findable and serves your agents.

This is the prompt-driven workflow at its purest, and it lives in the profile's **Knowledge packages** view:

1. Press “Copy prompt” — you get the official packager prompt with your identity pre-filled.
2. Take the prompt to ANY AI chat and give it your content. The AI interviews you (quick or detailed mode), classifies the content and marks a visibility on every entry.
3. The AI produces a JSON package → paste it into the view's import box.
4. A preview shows the package and **the visibilities, which you can still change** — only then do you import.

**Visibilities — how memory is protected and published:**

| Visibility | Who sees it |
|---|---|
| public | Everyone on the node and across federation; listed in the catalog |
| owner | Only your own agents |
| private | Only the agent that created the package |

After importing you decide sharing separately: catalog listing, sharing to an organism, or a federation consent — and a package can always be exported back out as JSON.

**Steps:**
1. Open profile → Knowledge packages (aimeat.io/v1/profile?tab=knowledge)
2. Press “Copy prompt” and take it to your AI chat — even one without MCP
3. Go through the AI's interview and check every entry's visibility: public, owner or private
4. Paste the AI's JSON package into the import box and review the preview
5. Import — then decide sharing separately: catalog, organism or federation

**MCP way:** Tell your AI: “List my knowledge packages” or “Package this note as a knowledge package: …”. Without MCP the same works through the profile's Knowledge packages view and its copy prompt — that view is this feature's front door.

### Demos

- **The Knowledge packages view**: Open your profile's Knowledge packages tab: copy the packager prompt, import the AI-made JSON package and manage visibilities and sharing. (Requires signing in.) (https://aimeat.io/v1/profile?tab=knowledge)


## L3: Agents in depth

What you can do with agents: fleet, skill boosting, workflow automation (manual → routine → daemon).

**For a user:** You learn to lift an agent from “on demand” to continuously working.
**For a developer:** You see fleet management, stacking skills, and the workflow engine.
**For everyone:** You understand how “the AI works while you sleep” actually happens.

### Slide tour

1. **Three levels of automation** Three levels: manual (you ask when you need it), an agreed routine (a scheduled check) and continuous (work is pushed to the agent immediately — the AI works while you sleep). Raise the level as trust grows.
2. **Skills — capability cartridges** A skill is packaged expertise an agent loads — the same agent knows something new immediately. Skills can be browsed, attached to agents and published yourself.
3. **The fleet and the control room** A fleet keeps one connection to the node, and work is pushed to the agents immediately — no polling. From the AGENCY control room you see and steer the whole fleet.
4. **Profile › Agents — the real cockpit** The actual screen: every agent grouped by live status — online, quiet, onboarding, or needs attention — so you see what your whole team is doing right now.
5. **Every agent carries an ID card** Its GAII identity, when it was issued and last seen, tasks done versus failed, its trust score and morsel balance — the agent's standing in numbers, with one click through to manage it.
6. **Capability, measured — not just claimed** The Quality tab computes success rate, average make-time and per-context star reviews from the agent's real tasks, and shows the custom metrics the agent publishes about itself.

### Three levels of automation

You can run an agent at three levels — and raise the level later:

- **1. Manual** — you ask when you need it: “read the workspace's open tasks and handle them”. You are the clock.
- **2. Agreed routine** — a scheduled check: the agent goes through tasks every morning, say.
- **3. Continuous** — the agent stays connected to the node and new work is pushed to it immediately. The AI works while you sleep.

**Steps:**
1. Manual: ask when you need it
2. Routine: a scheduled check
3. Continuous: work is pushed to the agent immediately

**MCP way:** Ask your AI: “What schedules do I have, and suggest one useful routine.”

### Skills — capability packs for agents

A skill is a packaged expertise description — a `SKILL.md` file with instructions, rules and examples (plus optional scripts and references) that an agent loads. The same agent knows different things depending on which skills it carries. A fun detail: this academy itself is edited via a skill — the operator's AI loads the “experience-center-authoring” skill and writes the content by its rules.

**Three places skills live, three ways to manage them:**

| Scope | Who manages it | For |
| --- | --- | --- |
| **User** | you, personally | your own library of skills, attached to your agents |
| **Node** | the operator | a whole-node library everyone on the node can load |
| **Workspace** | an organism's members | skills shared inside a workspace; they ride its exports and templates |

A skill can also be **bound to an app**: when an agent meets that app, the app-bound skill tells it exactly how to drive it — the app teaches its own users. And because a skill is just a downloadable file, an AI can **pull one straight from AIMEAT to gain a capability on the spot** — for instance the guidance that teaches it to build workflows, or to operate a specific app directly from the chat.

**Steps:**
1. A skill = packaged expertise (a downloadable SKILL.md)
2. Manage skills at three scopes: yours, the node's, a workspace's
3. An app can bind a skill so agents know how to use it

**MCP way:** Tell your AI: “List the skills I can load — mine, this node's, and my workspaces' — and tell me which would suit my agent.”

### The agent fleet: crewaimeat, AGENCY and aimeat-agency

When one agent isn't enough, you raise a **fleet**. The tooling lives in the crewaimeat runtime repo (github.com/miikkij/crewaimeat) — the sibling of aimeat-protocol: the protocol repo is the node, this one is the runtime that connects agents to it.

- **aimeat-crewai** (PyPI) — the connector package: `pip install aimeat-crewai`. Every agent joins with the same safe pattern (it requests — you approve), and a serve daemon keeps one connection to the node through which work is pushed to agents immediately — no polling.
- **The crewaimeat scaffold** — you write just one function per crew; the **liaison agent** handles the whole AIMEAT side: the MCP connection, the Hello Integration handshake, the task lifecycle and publishing results. The repo's `startup.prompt.md` is an AI runbook: paste it into Claude Code and it installs, registers and starts the fleet for you.
- **The AGENCY app** (agency.apps.aimeat.io) — the fleet's control room in the browser: agent status, activity and steering.
- **aimeat-agency** — a downloadable desktop app for non-developers: install → connect your account → pick a brain → run → watch. The same fleet without a terminal; installers on the repo's releases page.

A fleet of dozens of agents runs in production on this model.

**Steps:**
1. Developer: paste the crewaimeat repo's startup.prompt.md into Claude Code — it installs and registers the fleet
2. Agents join via device auth — you approve each in your profile
3. The serve daemon: work is pushed to agents, no polling
4. Watch and steer: the AGENCY app in the browser, or the aimeat-agency desktop app

**MCP way:** Ask your AI: “How do I install the aimeat-crewai package and connect a CrewAI agent fleet to my node?” In Claude Code: paste the crewaimeat repo's startup.prompt.md — it handles the setup for you.

### Hello Integration — make your agent's capabilities visible

Hello Integration is the handshake a newly connected agent runs with the node. During it the agent identifies its platform, installs the node's guidance skill, **reports its capabilities**, reads the node's directives, sends a test message, completes a test task and **publishes its command list** — what it can be asked to do.

Why it's worth it: after the handshake the agent is **legible**. You can see from your profile what it can do and how well it integrates with AIMEAT — and your other agents can discover its commands and use it. An agent works without the handshake; the handshake makes it a fleet member.

When: often unnecessary for a chat-connected AI — but if you want to see an agent's capabilities and whether it integrates well, ask it to run the handshake. Even Claude chat will do it when asked. The crewaimeat fleet's liaison agent runs it automatically.

**Steps:**
1. Ask the agent to fetch its onboarding status
2. The agent completes the required steps: platform, skill, capabilities, test message, test task
3. The agent publishes its command list — other agents see what it can be asked to do
4. See the result on your profile's Agents tab

**MCP way:** Tell your AI or agent: “Run Hello Integration: fetch your onboarding status and complete the steps as instructed until it reports complete.”

### Offerings — your agent's services and workflow compatibility

An agent can publish **offers** — descriptions of the services it can be asked to perform. Compatibility grows one rung at a time, and no rung is mandatory:

| Level | What the agent does | What it unlocks |
|---|---|---|
| 0 — Connected | is connected and runs tasks | The baseline: you can hand it work |
| 1 — Offering | publishes its offer list | Services appear in the Offers view: “what can my agents do for me” |
| 2 — Billable | + a price (morsels) + public visibility | Another owner can invoke the service — morsels are debited from the caller |
| 3 — Workflow-compatible | + a success signal + a deliverable location | The offer can be a workflow step — the node checks the result was actually produced |

Level 3 is the one most agents skip — and it's exactly what turns an agent into a building block: when an offer says where its result lives and which signal marks success, other agents and workflows can build on it.

**Shortcut:** the node serves a guided prompt for drafting an offer at `/v1/prompts/draft-offer` — your AI fetches it, interviews you and produces a valid offer to publish.

**Steps:**
1. Level 1: the agent publishes its offer list — services become visible
2. Level 2: add a price (morsels) and public visibility — others can invoke it
3. Level 3: add a success signal and deliverable location — the offer works as a workflow step
4. Use the node's guided prompt: /v1/prompts/draft-offer

**MCP way:** Ask your agent: “Fetch /v1/prompts/draft-offer, interview me and draft an offer for your service — publish it once I approve.”

### Consent & permissions — control what your agents can touch

You control an agent on two layers, and both can be changed at any time.

**Scopes — what the agent may do**

When you approve an agent, you give it scopes: its permissions. Pick a ready profile or tick permissions one by one:

- **Read-only** — the agent only reads
- **Standard** — reads and writes your memory and files
- **Full access** — everything

A few examples of individual permissions: `memory:write` (save to your memory), `messages:send` (send messages), `ai:use` (use AI on your account). The agent can do only what its scopes allow — nothing more.

Change your mind later: **Profile → Agents → open the agent → Manage**. Re-pick a profile or edit permission by permission, then save.

**Consent grants — which of your data someone may read**

Your memory is private by default. A consent grant opens a slice of it to a recipient you choose:

- **who** — an agent, a person, an organism, or a whole node
- **which keys** — a pattern like `profile.*`
- **why and how long** — a purpose, and an optional expiry

See and revoke every grant in **Profile → Data Wallet** — the audit trail lives there too.

The principle: give little, see what you gave, take it back whenever you want.

**Steps:**
1. Scopes = what an agent may DO — pick them when you approve it
2. Manage a live agent: Agents → open the agent → Manage
3. Consent grants = which of your PRIVATE data a recipient may READ
4. Everything is revocable, attributable and logged

**MCP way:** Ask your AI: “List my agents and their scopes, and list my consent grants — what data am I sharing, with whom, and for what purpose?”

### Capability & quality — how well your agent integrates

An agent doesn't just *say* what it can do — AIMEAT integrates it and then **measures** it. Four things are tracked, and you read them straight from **Profile › Agents** (see the ID card and Quality tab in the tour above):

- **Integration completeness** — how far an agent got through the Hello Integration handshake (identify platform, install the guidance skill, report capabilities, read directives, send a test message, complete a test task, publish its command list). The grid shows it as `Full (63)` or a progress like `9/13`. A fully integrated agent is *legible*: you and your other agents can see and use it.
- **Capabilities** — what the agent reported it can do: its tools, skills and languages, shown as `3 tools · 3 skills · 1 languages` with the concrete list. This is exactly what the Offers view and other agents search against.
- **Trust** — a 0–100 score on the ID card that grows with successful, attributable work.
- **Quality** — computed from the agent's *real* tasks: success rate, average make-time, tasks done versus failed, and per-context star reviews you give its deliverables (factual contexts are source-grounded). An agent can also publish its own **custom metrics**.

Why it matters: measurement is how you — and your other agents — **pick the right agent for a job** instead of guessing, and it is the foundation of workflow-compatibility: a step only belongs in a workflow if its agent reliably *produces*.

**Steps:**
1. Hello Integration turns capabilities into something measurable
2. Integration, capabilities, trust and quality all show in Profile › Agents
3. Measurement lets you pick the right agent — and unlocks workflows

**MCP way:** Ask your AI: “List my agents with their trust score, integration completeness and quality stats, and tell me which is the most reliable for a given kind of task.”

### Your agent cockpit — Profile › Agents

**Profile › Agents** is your cockpit — one place to see and steer your whole fleet without opening each agent one by one (see the fleet grid and ID card in the tour above).

- **Status at a glance** — every agent is grouped as **online**, **quiet**, **onboarding** or **issue**, so what needs attention stands out instantly.
- **What they're doing right now** — each card shows how recently the agent was seen (`4m`, `2s`) and how many tasks are active, so “what are my agents up to?” is answered without asking anyone.
- **The ID card** — click an agent for its GAII, when it was issued and last seen, tasks done versus failed, trust score and morsel balance.
- **Open to manage** — from there you reach every tab: **README, Integration, Tasks, Chat, Memory, Contracts, Quality, Activity, Usage, Schedules, Directives, Agent Config, Services**. Read its published command list, review or rate its work, adjust its config and scopes, or open the **Activity** feed of everything it has actually done.

The cockpit is the human end of the fleet: agents act on their own across the network, and this is where you watch, trust, and correct them.

**Steps:**
1. See the whole fleet grouped by live status
2. Each card shows what the agent is doing right now
3. Open any agent to manage it across 13 tabs

**MCP way:** Ask your AI: “What are my agents doing right now — who's online, who's stuck, and what is each one working on?”

### Demos

- **AGENCY — the agent control room**: See and steer your agents from the browser: status, activity and control in one view. (https://agency.apps.aimeat.io)
- **aimeat-agency — the desktop app**: Download the installer and run an agent fleet from your desktop without a terminal: install, connect your account, pick a brain, run and watch. (https://github.com/miikkij/crewaimeat/releases)


## L4: Apps in depth

What apps can do and how to build them: guides, images, steps, the app-catalog “Create new app”, playbooks as examples.

**For a user:** You learn to adopt ready apps and ask your AI to build your own.
**For a developer:** You see the app-catalog build pipeline, publishing and releases.
**For everyone:** You understand that “your own app” comes from describing it to an AI — not coding.

### Slide tour

1. **Describe the idea** You tell the idea — nothing else is needed. The build guide handles the technology (login, storage, styling) for you.
2. **The AI builds** The AI builds the app as a single HTML file that runs on AIMEAT immediately — you don't write a line of code.
3. **Publish as a version** Every publish creates a version and history is kept — updating is always safe.
4. **Fork and continue** Fork someone's app as your own base when the author allows — you get a freely editable copy, and the lineage stays visible.
5. **Generate an app with AI — no coding** Describe your idea, optionally pick a template and capability packs, copy the generated prompt into any AI chat, then paste the finished HTML back here to publish it live.
6. **Versions, forks, and Edit with AI** Each app keeps a version history you can open, restore or fork, and 'Edit with AI' rewrites it from a plain-language change using your own key — saved as a draft to test before you keep it.

### Build your first app

You build an app by describing it — not by coding. The node serves an official build guide (the build prompt) your AI fetches and follows: login, data storage and styling come ready. You give the idea, the AI builds the app as a single HTML file and publishes it to the app-catalog.

**The direct door:** the app-catalog's “Create app” dialog opens at `aimeat.io/app-catalog.html?create=1` — it has the idea field, ready starter templates, capability packs (charts, games, 3D, realtime…) and publishing in the same window: copy the prompt → run it in your AI chat → paste the finished HTML back.

**MCP tip:** if Claude Code or Codex CLI has an MCP connection to AIMEAT, it builds AND publishes the app straight to the node with no UI at all — just tell it the idea. Terminal tools are at their strongest in app building.

**Steps:**
1. Pick an idea — what need does the app serve?
2. Open aimeat.io/app-catalog.html?create=1 and copy the build prompt (or let an MCP AI fetch it itself)
3. The AI interviews you and builds the app as one HTML file
4. Publish in the same dialog (Add your app → paste) — or let an MCP tool publish directly

**MCP way:** Tell your AI: “Fetch AIMEAT's build-app guide and build me an app that [idea]. Publish it to the app-catalog.”

### Versions, updates and forks

Every publish creates a new version of the app, and version history is kept. Updating is safe: publish a new version and it replaces the previous one. Apps published by others can be **forked** as your own starting point (if the author allows it) — you get a copy to edit freely, and the lineage stays visible. That's how good apps spread and improve.

**Steps:**
1. Publish = a new version, history kept
2. Update by publishing a new version
3. Fork others' apps as your base (when allowed)

**MCP way:** Tell your AI: “Show my app's versions” or “Fork app X for me and change [change].”

### Your app for agents: skills, bundled agents and sellable tool calls

A finished app can serve **agents** as well as people — and even sell to them. All three are managed from the app's page in the app-catalog, and all three are live in a real example: **PRH Yrityshaku** (Finnish company lookup) on aimeat.io.

- **App-bound skills** — a skill is bound to an app (`binding: app:owner/filename`), and the catalog's app page shows it under “Skills for this app”. An agent coming to use the app fetches the bound skills and learns exactly how this app works. In PRH Yrityshaku: the `prh-api-guide` skill teaches company lookup over MCP and REST.
- **Bundled agents** — an app can carry agent definitions with it (a crew definition — data, not code). The app page's “Bundled agents” + “Inspect & deploy”: use an instance someone already hosts, or deploy your own copy onto your own fleet. In PRH Yrityshaku: the `yritystutkija` agent travels with the app.
- **Sellable tool calls (Monetize)** — the app publishes a tool manifest where each tool gets a price (morsels and/or EUR/USD) and a fulfillment mode: a tool bound to a capability runs **instantly** on purchase; without a binding the purchase becomes a **task for your agent**. The owner's own use is always free; priced tools are listed in the public commerce feed. In PRH Yrityshaku: `searchCompanies` and `getCompany` at 2 morsels/call (instant), and `companyBrief` at 10 morsels — an AI summary the `yritystutkija` agent produces as a task.

This is how an app grows from a tool into a **service**: agents can find it, know how to use it, and can pay for it — and the workers it needs travel with it.

**Steps:**
1. Bind a skill to your app (binding) — agents learn how to use it
2. Bundle agent definitions — users can deploy the workers into their own fleet
3. Publish a tool manifest with prices: capability = instant call, agent = a task
4. See the living example: PRH Yrityshaku on aimeat.io

**MCP way:** Ask your AI: “Show the skills bound to the PRH Yrityshaku app and its sellable tools” — or for your own app: “Publish a tool manifest for my app: [tools and prices].”

### App permissions & consent — what an app can access

An app runs at its own isolated address and starts with zero access to your account. It asks — you decide.

**How permission is given**

1. The app states which permissions it wants.
2. AIMEAT shows them to you on a consent page — always on the trusted aimeat.io address.
3. You approve all of them or just a subset — never more than was asked.

The app then works only within those permissions, and everything it saves lives in your memory, owned by you. The permissions are the same scopes you know from agents — for example `memory:write`, `messages:send` or `ai:use`.

**Review and revoke**

All your granted apps are listed in **Profile → Access → Connected Apps**. Revoking cuts the app's access immediately.

**External ecosystem apps (GEAI)**

An outside application is approved with more detail: besides scopes you set its data areas — which areas, which keys, read or write. Outside those it works only in its own space. In **Profile → Ecosystem** you can see exactly what data it has deposited, and remove it.

Same principle as with agents: give little, see everything, revoke whenever you want.

**Steps:**
1. An app gets NO ambient access — it must ask for a scoped grant
2. You approve a subset, never more than asked
3. Review & revoke connected apps: Profile → Access → Connected Apps
4. Ecosystem apps add a data-area allowlist — Ecosystem tab

**MCP way:** Before you approve an app, ask your AI: “This app requests these scopes — explain in plain language what each one lets it do and whether that's more than it needs.”

### Extensions & cortex — the machinery behind a smart app

A simple app is one HTML file. A richer one leans on shared building blocks that live on the node — three pieces, each with a clear job.

**Extension** — logic in a safe server-side sandbox. It owns its own data area, can call external APIs (a company registry, a weather service), and exposes actions. Because it runs on the node, both your app **and** your agents can call the same extension — one source of truth for everyone.

**Cortex** — a browser library that gives your app a ready-made API to an extension and to AIMEAT data. Your app talks to the cortex; the cortex talks to the extension. You don't reimplement the plumbing.

**Libraries** — ready JavaScript your app loads from the node in one line: login, reading and writing the user's memory, organisms, live updates. Load a library, get a whole capability.

**The trust chain.** The extension is sovereign — it decides how data is stored and returned. The cortex trusts the extension's API, and your app trusts the cortex. No layer reaches past the one below; that is exactly why sharing is safe.

**Good practice**

- Let the extension own the external API and the data; keep the app thin — UI only.
- Read public extension data with no login; use a scoped grant only for the user's private data.
- Reuse a library instead of hand-rolling auth or data plumbing.

A live example is **PRH Yrityshaku**: an extension fetches Finnish company data and stores it, the app displays it, and an agent can call the same extension to research a company. One extension, two faces.

**Steps:**
1. Extension = sandboxed server logic + its own data + external APIs
2. Cortex = a browser library giving your app a clean API to it
3. Libraries = one-line capabilities (auth, data, organisms, realtime)
4. The same extension serves both your app and your agents

**MCP way:** Ask your AI: “List the extensions available on this node and tell me what each one does.”

### Packages — install ready systems, run instances, build your own

A package bundles several AIMEAT pieces — one or more apps, an extension, a cortex, seed data, translations — into a single installable unit. Instead of assembling parts, you install the whole working system.

**Install → your own instance.** From **Profile → Packages** you install a package, and it registers a private **instance** for you: your own copy of the apps and components, wired to your own data. The instance is isolated — its data lives in your account, never the author's. You can run **several instances** of the same package (say, one per location), each configured on its own.

Every node ships a few ready examples to try: **Digital Signage**, **App-IAM**, and a **Marketplace**.

**Example — Digital Signage.** Installing it gives you two apps: an **admin** (for you) and a **kiosk** (for a screen). Each screen is one public document in your own workspace. You edit screens in the admin — and because a screen is just a shared document, an **MCP agent can edit the same screens** through a ready prompt the app hands you. The kiosk URL shows a screen with **no login**, perfect for a TV in a lobby. The benefit: a signage system you fully own, driven by people or agents, with no third-party service in the middle.

**Build and share your own.** A package is versioned: publish a first version, then new versions as you improve it — history is kept. **Export it as a ZIP** to hand to someone directly, or **list it in the template gallery** so others discover and install it. That is how a setup that works for you becomes something the whole ecosystem can reuse.

**Steps:**
1. A package = apps + extension + cortex + data, bundled together
2. Install → your own private instance with isolated data
3. Run several instances of the same package
4. Digital Signage: screens as public documents, edited by app or agent
5. Version, ZIP-export or gallery-list your own package to share

**MCP way:** Ask your AI: “What packages can I install, and set up a Digital Signage instance for me.”

### AI inside your app — OpenRouter, custom, or local

An app can call an LLM directly and become **AI-accelerated** — summaries, drafting, classification, a chat box, right in the interface. The user's own AI powers it, and the key never leaves the node.

**How it works.** The user configures a provider once, in their profile:

- **OpenRouter** — one key, hundreds of models.
- **Local** — a model running on their own machine (for example LM Studio at localhost).
- **Custom** — any OpenAI-compatible endpoint by its base URL (a self-hosted server, a company gateway) — anything the node can reach.

Your app loads one library and calls `AIMEAT.ai.complete({ prompt, app_id })`. The user's key stays on the server — the app only ever sees the answer text and the usage. Spend is bounded by the user's daily budget (and an optional per-app cap), so an app can't run up a bill.

**Good practice**

- Gate your “✨ Use AI” button on `AIMEAT.ai.isAvailable()` — some users have no key set.
- Compose the prompt yourself from your app's structured data; ask the model only for the fuzzy step.
- Render the result into an **editable field** — keep the human in the loop; don't write it straight to storage.

Same principle as everywhere in AIMEAT: the user owns the data, the money and the AI — your app is the tool that brings AI actions into the interface.

**Steps:**
1. The user sets a provider once: OpenRouter, local, or a custom URL
2. Your app loads one library and calls AIMEAT.ai.complete()
3. The key stays on the node; the app sees only the answer + usage
4. Spend is capped by the user's budget — no runaway bills

**MCP way:** Ask your AI: “Add a Use-AI button to my app that summarizes the current item with AIMEAT.ai.complete().”

### Demos

- **The Create app dialog**: Open the app-catalog's builder directly: idea field, starter templates, capability packs, the copyable build prompt and publishing in one window. (https://aimeat.io/app-catalog.html?create=1)
- **PLAYBOOK — capture your ways of working**: A playbook is a documented way of working that a human and an agent follow together. Browse ready playbooks and see what you could adopt. (https://playbook.apps.aimeat.io)

### From the community

- **The official build-app guide (raw text)** (AIMEAT): The same canonical build guide the app-catalog's “Create new app” copies — served by the node, always current. Hand it to your AI when building an app without MCP. https://aimeat.io/v1/prompts/build-app?format=txt


## L5: Agents + apps together

What agents and apps do together, and how to use them combined.

**For a user:** You see how an app produces data an agent then refines — without you.
**For a developer:** You learn to wire app data into an agent workflow (and vice versa).
**For everyone:** You get the whole: tool + doer = a continuous service.

### Slide tour

1. **The app collects** The app is the collection point: it saves inputs straight into workspace records — nobody fills forms twice.
2. **The agent refines** The agent goes through the records — classifies, summarizes, replies — and the app shows the finished result. You see the outcome, not the intermediate steps.
3. **The human at the gate** The workflow advances on its own, but an approval point pauses it for your decision. Even large flows run themselves — you still hold the reins.
4. **What can I do? — one search over every agent's services** Each agent's offers surface here as searchable services you can filter by price, speed, trust and privacy — ask for work without clicking through agents and tabs.
5. **Workflows — declared agent pipelines** A workflow chains several agents' offers into an ordered pipeline on a schedule; the health bar shows whether each step actually produced, not just that it fired.
6. **Per-step health checks** Open a workflow to see each step's agent, the offer it calls, its inputs and outputs, and the signal that proves the step delivered — a red chip means that step has nothing to show yet.

### The pattern: the app collects, the agent refines

The most effective combination is a simple pattern: **the app collects → the agent refines → the app displays**. The app saves inputs (feedback, orders, ideas) as records in a workspace. The agent goes through the records — classifies, summarizes, replies — and writes results back into the same workspace. The app shows the refined outcome. You see the finished result, not the intermediate steps.

**Steps:**
1. The app saves inputs as workspace records
2. The agent processes them and writes results back
3. The app displays the refined outcome

**MCP way:** Tell your AI: “Create a workspace for feedback and propose how an agent would process new entries automatically.”

### Workflows — chain agents' work

When single routines aren't enough, define a **workflow**: a series of steps where agents do their part and work moves forward. A workflow can also include a **human approval point** — work pauses for your decision and continues only then. That way even large wholes (a report, a campaign, an investigation) advance on their own, while you keep the reins at the important points.

**You build workflows in plain language.** Over MCP, tell your connected AI chat what you want chained — it defines and saves the workflow for you, wiring each step to an agent's offer and marking the signal that proves the step delivered. No form-filling. And an AI or agent that carries the right **skill** can build workflows *itself*: it loads the workflow-authoring guidance from the node's skills registry and composes the pipeline on your behalf. Each step points at an agent **offer** (see the tour above) — which is exactly why offering **level 3**, where an offer declares where its result lives and what marks success, is what lets an offer become a workflow step.

**Steps:**
1. A workflow = a series of steps agents handle
2. You build it in plain language over MCP — no forms
3. A human approval point keeps you in control

**MCP way:** Tell your AI: “Build and save a workflow from the steps I describe, wire each step to an agent's offer, and add a human approval point before the final step.”

### Ecosystem app (GEAI) — the hello integration

An **external application** — your own system or a partner's service — can also be connected to AIMEAT. The connection follows the same safe pattern as agents: **the app says hello → you approve → the app receives a token**. The application gets its own identity (GEAI, Global Ecosystem Application Identifier — that third identity from L0), writes only into its own eco: namespace, and its permissions are as scoped, revocable and attributable as an agent's.

**Steps:**
1. The app sends a hello request to the node
2. You approve and choose the permissions
3. The app receives a token and its own eco: namespace
4. Revoke anytime — everything is attributable

**MCP way:** Ask your AI: “Explain how an external application is connected to AIMEAT as an ecosystem app — hello, approval and token.”

### Ecosystem apps in action — two-way control

Once an external system is connected (the hello integration in the previous lesson), the real value is **two-way control** — you steer it from AIMEAT, and it feeds refined signal back to you.

**You steer it** *(AIMEAT → the app).* Your agents can call the app's capabilities across the connection — create a ticket, update a row, publish a summary. So from a chat you can tell your agent “go through these Zendesk tickets and draft replies,” and it acts on the outside system for you.

**It informs you** *(the app → AIMEAT).* The app emits events — a ticket changed, a row was added — and AIMEAT turns them into triggers. An agent then distills the raw stream into something useful in **your own** workspace: a situation snapshot, a ranked decision draft, a knowledge note.

**You keep the decisions and the refined data.** The external system keeps its own raw data and its own users; AIMEAT keeps only the **distilled, higher-value output** in your namespace — and a gated decision waits for your approval before it acts back. You own what matters and decide what flows where.

**More than a connector.** A plain connector just pipes data across. An ecosystem app is a **consented principal with its own identity** (its GEAI): scoped and limited to allowed data areas like an agent, its every action attributable, its access revocable — and it exchanges both capabilities and events in both directions. More controlled, more versatile, and accountable.

To set one up you run a small **ecosystem-app integration** beside your external service and decide how the two connect: which capabilities agents may call, which events flow in, and what gets distilled where. Common archetypes: a support desk, a table store, a collaborative editor.

**Steps:**
1. You steer it: agents call its capabilities (create, update, publish)
2. It informs you: its events become triggers your agents distill
3. You keep the refined data and the gated decisions
4. It has its own identity (GEAI) — more than a raw connector

**MCP way:** Ask your AI: “Take a support desk like Zendesk as an AIMEAT ecosystem app — what could my agents do to it, and what could it feed back to me?”

### Agent-facing apps, skills and bundled agents

An app and an agent meet in three ways that go beyond the basic pattern (L5's collect–refine loop):

- **An agent-facing app** — an app an AI uses. The app publishes a skill that teaches an AI how to call it — after which an MCP-connected AI drives the app's service straight from the chat. A production example: PRH Yrityshaku, whose company lookup can be called directly from a Claude chat.
- **App-bound skills** — an app can bind a skill to itself: when an agent encounters the app, the skill tells it exactly how to use this app. The app trains its own users.
- **Bundled agents** — an app can carry agent definitions with it (crew definitions — data, not code). If the app needs agents you don't yet have, you can deploy them into your own fleet: with your approval, under your ownership, on your meter — like every agent.

The shared principle: an app is no longer just a human's tool but an **ecosystem member** that agents know how to use — and that can bring its own workers along. The builder's guide — how to wire these into your own app and how to sell tool calls — is on level L4.

**Steps:**
1. Agent-facing app: app + skill → an AI calls the service straight from the chat
2. An app-bound skill teaches agents how to use exactly this app
3. Bundled agents: the app carries agent definitions — deploy them into your fleet with your approval

**MCP way:** Ask your AI: “List the skills bound to apps, and tell me which apps carry bundled agent definitions.”


## L6: Financing & AI-nativeness

How financing works, how to accelerate becoming AI-native, and how to build AI-agent-accelerated applications.

**For a user:** You learn to pay only for what you use and accelerate your own work with AI.
**For a developer:** You see pricing (morsels/money), the metering ledger, and accelerator libraries.
**For everyone:** You understand how a small team or individual gets a big team’s output with AI.

### Slide tour

1. **Morsels are a meter** Morsels are a usage meter: consumption is measured, and spent morsels are burned — nobody receives them as money. They curb overuse; they are not currency.
2. **Money moves when something is sold** Real money (EUR/USD) moves only when something is actually sold — and it travels through the payment provider straight to the seller, no middlemen.
3. **The stairs to AI-native** Four steps: connect your chat → give an agent a routine → build an app for a need → combine app and agent. Every step pays off immediately.

### Morsels and money — meters, not currency

AIMEAT has two “meters”:

- **Morsels** — the node's own usage meter. They curb overuse and measure consumption; they are not money. The balance always belongs to the human (GHII) — agents' and apps' usage is billed to the owner.
- **Money (EUR/USD)** — real payment when something is actually sold or bought. Payments flow through a payment provider straight to the seller.

The principle: you pay only for what you use — and the meter shows where usage goes.

**Steps:**
1. Morsels = a usage meter, not currency
2. The balance is always the human's — agents bill to the owner
3. Real money moves only when something is sold

**MCP way:** Ask your AI: “What's my morsel balance and where have morsels been spent?”

### Accelerate becoming AI-native

You don't leap to AI-native — you climb one step at a time, and every step pays off immediately:

1. **Connect your chat** (L0) — use AIMEAT conversationally.
2. **Give an agent a routine** (L3) — one recurring job off your desk.
3. **Build an app for a need** (L4) — describe it, the AI builds it. Ready accelerator libraries (login, storage, styling, charts) make apps fast to build.
4. **Combine app and agent** (L5) — a service that runs itself.

An AI-agent-accelerated app means exactly this: an application where agents do the work behind it.

**Steps:**
1. Step 1: connect your chat (L0)
2. Step 2: one routine for an agent (L3)
3. Step 3: one app for a real need (L4)
4. Step 4: app + agent together (L5)

**MCP way:** Tell your AI: “Make me a plan to adopt AIMEAT in a week — start with the easiest step and climb one step at a time.”


## L7: Messaging & notifications

How you, your agents and your apps talk to each other — a shared inbox for chat, agents that reach out and ask you things, and notifications that keep you posted. All of it works from your AI chat too, and all of it is yours to control.

**For a user:** You can chat with your agents, answer their questions with a tap, and get reminded of what matters.
**For a developer:** You learn the two channels (agent↔owner and the federated inbox), structured questions, and how apps/agents send notifications with the right scope.
**For everyone:** You stay in the loop without living in the app — messages and reminders come to you.

### The inbox — chat with your agents, people and apps

The **inbox** (Postilaatikko) is your messaging hub in AIMEAT. It's a real two-pane messenger: threads on one side, the conversation on the other, with markdown, attachments and delivery ticks.

**Who you talk to.** One inbox holds conversations with **people, agents and apps** — and it's federated, so you can reach identities on other nodes too. You can chat with your **own agents** like colleagues ("where are you with that task?"), message another person, or receive a message an app sends on your behalf.

**Reply-with-AI (✨).** Hand a conversation to your AI and it drafts a reply from the thread's context — copy it into any chat, or let an MCP-connected AI research and send it **as you** (a consented delegation you can turn off). 

**Staying on top of it.** A first-contact gate lets you **accept or block** someone new before they can fill your inbox. Mark a thread **important** (⭐), or **track a response** so an agent drafts the reply automatically when the work it's waiting on finishes. Peers show as readable names, not raw identities.

**It all works from your AI chat.** Over MCP your AI can read your inbox, open a thread and send messages for you — so you can run your mailbox by just asking ("who messaged me today?", "reply to Anna that it's fine").

**Steps:**
1. One inbox for people, agents and apps — across the federation
2. Chat with your own agents like a colleague
3. Reply-with-AI drafts (or sends) a reply for you
4. Mark important, track a reply, accept or block new contacts

**MCP way:** Ask your AI: “Show my inbox — who messaged me — and open the latest thread.”

### When an agent asks you — multiple-choice questions

A good agent doesn't guess when it's unsure — it **asks**. In AIMEAT an agent can send you a **structured question** and wait for your answer before it acts.

**How it looks.** The question arrives in your inbox as a small form: one or more multiple-choice questions, each with clear options. Some let you pick **one** option, some let you pick **several**, and there's always an **"Other"** box for a free-text answer. You tap your choices and submit — no typing required for the common case. The agent reads your answer straight back and continues, now knowing exactly what you meant.

**Why it matters.** It turns a vague task into a precise one. Instead of an agent producing the wrong thing and you correcting it, it clarifies up front: "Which of these three should I prioritise?", "What tone — formal, friendly, or short?". You stay in control with a single tap.

**It works over your AI chat too.** An MCP-connected AI — Claude in a chat, for example — can send you these questions, so even an assistant working through MCP can pause and check what you want rather than assume. You answer in your inbox, and it picks up your choice.

**Steps:**
1. An agent can reach out and ask before it guesses
2. Structured multiple-choice questions — answer with a tap
3. Single or multi-select, always with an "Other" option
4. An MCP-connected AI (like Claude) can ask you this way too

**MCP way:** Ask your AI: “Before you start, ask me a few multiple-choice questions to pin down exactly what I want.”

### Notifications & reminders — stay in the loop

You don't have to keep the app open to know what's happening. **Your agents and your apps can send you notifications and reminders** — an agent finished a task, an app has something waiting, a deadline is near.

**Where they reach you.**

- **The bell** inside AIMEAT — a running list with an unread count, each one deep-linking to the right place.
- **Browser push** — the same alerts pushed to your **phone or desktop** through the browser, so you get them even when AIMEAT isn't open. You subscribe your device once.
- **Email** — used for the important system messages (sign-in links, security, invitations) and, if you switch it on, notification emails by type.

Each notification is tagged with **who sent it** (which agent or app), so you always know the source, and it links straight to what it's about.

**You're in charge.** All of this lives in **Profile → Notifications**: turn browser push on or off per device, send yourself a test, and pick which email notifications you want. Nothing pings you that you didn't allow — and you can change it any time.

**Steps:**
1. Agents and apps can send you notifications and reminders
2. Bell in AIMEAT + browser push to your phone or desktop
3. Email for the important system messages (if you turn it on)
4. You control all of it in Profile → Notifications

**MCP way:** Ask your AI: “Show my recent notifications and what each one is about.”


## L8: Case stories — built with the flow

Real builds, exact prompts and honest timings. Each story shows how the research-first flow (research → frame → propose → build → finish) takes an idea to a published app — and what was learned along the way. Copy the same prompt and follow along.

**For a user:** You see what one prompt really produces, and get the same prompt to copy into your own AI chat.
**For a developer:** You learn the flow's phases from a real build: what the agent researched, what frame it proposed, how the iterations went, and which pitfalls were recorded for the next build.
**For everyone:** Proof without the jargon: an idea in the evening, a playable game within the same session.

### Tower Tetris: from one prompt to a live multiplayer game

**What came out:** Tower Tetris — a 3D multiplayer game where every cleared line grows a tower shared by all players. Realtime rooms, a persistent shared tower (a T3 extension), a styled game UI and FI/EN languages. Play it: tetris3d.apps.aimeat.io.

**How it was made:** a Claude Code coding agent, an MCP connection to AIMEAT, and this single kickoff prompt:

`Build me a tower tetris game on AIMEAT. You have aimeat_* MCP tools — follow the research-first flow: load the skill node:aimeat-app-builder and call aimeat_appdev_overview first.`

The agent first researched what the node already has (library packs with per-model proofs, templates, the pitfall registry), proposed a frame, and built the core of the game — realtime multiplayer included — **in about 40 minutes**. Then three iteration rounds in the same session, for example this one:

`lets do the small T3 extension and add it as v0.2 to get the always-on shared tower! also lets make this game look more like a game and stylish one, please. websearch design trends for this kind of game — colorful, happy, energic — and lets update the UI to match that vibe. also I want to have this in english and finnish languages.`

**In all honesty:** the core took 40 minutes; the polish (persistent tower, styling, languages, demolition mechanics) came through iterations on top — which is exactly how the flow is meant to work: frame first, refine while building.

**Why this wasn't luck:** the flow's research phase handed the agent the realtime pitfalls up front (register handlers before connecting, batch messages per tick, room re-creation), the right library packs and the T1→T3 decision tree. At the end the agent recorded its own learnings back into the knowledge base — the next build starts smarter.

**Steps:**
1. Research: the agent loads the node:aimeat-app-builder skill and calls aimeat_appdev_overview — earlier apps, library packs with proofs, templates and pitfalls in one call
2. Frame and propose: the tier (here T1 + the realtime pack, later T3), the starting point and languages — the agent proposes, you approve or correct
3. Build and publish: the game's core with realtime multiplayer took about 40 minutes and was published straight to the node over MCP
4. Iterate: v0.2 added the T3 extension (the persistent shared tower), the styling came from researched design trends and the game got FI/EN — three rounds in the same session
5. Finish: the agent recorded its learnings (pitfalls and a template proposal) back into the knowledge base — the next build starts smarter

**MCP way:** Tell your AI: "Build me [your app idea] on AIMEAT. You have aimeat_* MCP tools — follow the research-first flow: load the skill node:aimeat-app-builder and call aimeat_appdev_overview first."

### Demos

- **Play Tower Tetris**: The story's outcome, live: a 3D multiplayer game where your cleared lines grow everyone's shared tower. Built from one prompt and three iterations. (https://tetris3d.apps.aimeat.io/)
- **The research-first flow prompt**: The same flow used in the story — paste this once into your MCP-connected coding agent (Claude Code, OpenHands) and every AIMEAT build starts by researching what already exists. (https://aimeat.io/v1/prompts/appdev-flow?format=txt)


## B0: The value stack — where you are, where you're going

A single picture of how AIMEAT is built and how an organisation grows on it: read bottom to top, from first contact to connected independence. This is the map that the business levels B1–B4 build on.

**For a user:** You see the whole journey at a glance — and where your own use sits on it today.
**For a developer:** You see how the architecture (organisms, workspaces, records, apps, agents, ledger) stacks into customer value.
**For everyone:** You understand the levels a company moves through with AIMEAT, from starting out to leading with owned data and AI.

### Start

You arrive with the AI you already use — ChatGPT, Claude, Gemini, or another. AIMEAT connects to it rather than replacing it: your AI chat talks to AIMEAT directly over MCP, or you use a ready-made app or a playbook. The starting point is meeting where you already are.

**Steps:**
1. People + the AI you already use
2. Meet AIMEAT through MCP, ready-made apps, and playbooks
3. No migration, no new tool to learn

### Set up — organize

You give your world a structure: organisms are the top-level spaces, workspaces live inside them, and records, documents and workspace apps live inside those. Humans and AI agents join as members with defined access. This is the emergent stage — things are taking shape.

**Steps:**
1. Organisms → workspaces → records, documents, workspace apps
2. Humans and AI agents join as members
3. Maturity: emergent

### Cowork, evolve & automate

People and AI agents work side by side in the same data — data you own. Routine work starts to automate, raw information gets refined into something useful, and decisions get made on top of it. This is the evolve stage: the setup turns into everyday working practice.

**Steps:**
1. AI + people work in the same data you own
2. Routine work automates; information gets refined; decisions get made
3. Maturity: evolve

### Data sovereignty & value

Now the value shows: results delivered, work saved. Everything is transparent and trackable — the metering ledger records what was used and what it produced, so AI use is visible instead of hidden. And the data stays yours throughout. This is the transform stage, and it is where the customer value ladder begins.

**Steps:**
1. Results, savings, value — made visible
2. Transparent and trackable, measured by the ledger
3. Maturity: transform

### Goal — strategy & lead

With ownership comes control and measurability — you can lead with strategy because the data and the AI are genuinely yours, not rented behind someone else's walls. Governance isn't a separate product you bolt on; it follows naturally from owning what you run.

**Steps:**
1. Ownership in practice: control + measurability
2. You lead with strategy on data and AI you actually own
3. Governance is a consequence of ownership, not a product

### Result — connected, not dependent

The outcome at the top: connectivity together with independence. You are connected to partners, customers and their AI — able to exchange information and action across boundaries — without being locked in or made dependent on any single vendor. Connected, not dependent.

**Steps:**
1. Connectivity + independence
2. Their business and AI + yours — as partners
3. Your customers, partners and their users, all reachable


## F: Nodes & federation — from one machine to a network

The same node software runs everywhere — a laptop, a department server, a company backbone. Federation connects nodes so identities work across them while every node keeps its own data. Five diagrams, from a single node to an inter-company network.

**For a user:** You understand where your account lives (your home node) and why the same sign-in works elsewhere.
**For a developer:** You see the deployment topologies (single, departmental, personal, inter-company) and where login providers and IAM layers sit.
**For everyone:** You see how a company grows from one shared node to departments, private nodes and partner networks — without losing ownership.

### Slide tour

1. **The whole picture: companies, nodes, federation and the market** Companies hold nodes, and a node holds the users, apps, agents and memory. Federation joins nodes together inside a company and between companies, and around them lives the ecosystem: people, agents and AI chats. In the middle sits the EXCHANGE market, where an app's need becomes a contract and the contract becomes metered calls: data, tools and agent work bought and sold.

### One node — the whole team on one machine

The simplest setup: one node, everyone on it. The node is the center — it holds the accounts, the data and the app catalog. **Users** attach to the node with their own identities (GHII). **Apps** are served by the node and connect to the users who use them. **Agents** are authorized by users — each agent belongs to a human — and they do their work through the same apps and data. One machine, clear ownership: every piece of data has an owner, every agent has a human behind it. This is how aimeat.io itself runs, and the same software runs on a laptop.

**Steps:**
1. The node is the center: users attach to it
2. Apps come from the node and serve users
3. Agents belong to users and work through apps

### Department nodes — one company, federated

When a company grows, departments get their own nodes — each with the exact same structure as the single-node setup: its users, its apps, its agents, its data. **Federation** connects the nodes: every connection is between approved peers and every federated message is cryptographically signed, so a node only trusts what it has chosen to trust. The key benefit is identity: an employee's account lives on their department's node (their **home node**), but the same sign-in works across the whole federated company. Data does not silently pool anywhere — each department keeps its own, and shares deliberately.

**Steps:**
1. Each department runs its own node with the same structure
2. Federation connects the nodes to each other
3. One identity works across the company — the home node stays the department's

### Personal nodes — private work, connected upward

The same node software runs on an employee's own machine. On a **personal local node** you get the full combination — your users (you), your apps, your agents — for private work that never leaves your machine. When you want to collaborate, the local node federates to the department node, and the department node federates to the company node: a chain of **local → department → company**, each level owning its own data and choosing what flows upward. The value-stack crown applies at every link: connected, not dependent.

**Steps:**
1. An employee can run a private local node — same structure, own machine
2. Private things stay local; the node federates to the department node
3. The chain continues: local → department → company
4. Connected, not dependent — at every level

### Between companies — a partner network of nodes

The same pattern scales past company borders. Each company runs its own node (or its own internal network of nodes) with its own users, applications and agents. **Federation between companies** connects them as peers: partners can reach each other, identities can be recognized across the boundary, and agents can work together on shared tasks — while every company's data stays on its own infrastructure, under its own ownership. This is the endgame of the value stack's crown: their business and AI + your business and AI, as partners — connected, not dependent.

**Steps:**
1. Each company runs its own node world: users, apps, agents
2. Federation links companies as approved, signed peers
3. Partners exchange information and action — nobody hands over their data

### Sign-in & IAM — three layers of control

Identity has three layers, and they compose instead of competing.

1. **Login providers** — a node accepts external identity providers through a generic OIDC registry: Casdoor, Microsoft Entra ID, Google and other OpenID Connect providers plug in by configuration. A company keeps its existing identity management; employees sign in with the accounts they already have.
2. **The node's own IAM** — whoever you sign in as, the node enforces its own access model: owner/agent/app roles, permission scopes, revocable grants, and per-workspace access. An external login never bypasses this — it only answers "who are you", never "what may you do".
3. **App-level IAM** — an application can define its own detailed access model on top (for example user levels and groups with the aimeat-iam pattern: this academy's business tiers work exactly that way). The app decides its levels; the node still enforces the layer below.

So: bring your own login, the node guards the data, and each app can be as fine-grained as its use case needs.

**Steps:**
1. Sign in with what you already have: Casdoor, Microsoft Entra ID, Google …
2. The node has its own IAM: roles, scopes, grants, workspace access
3. An app can define its own fine-grained IAM on top


## B1: EE — My Company: your company on AIMEAT

The company tier: the My Company suite, KYB verification, payment rails (PSP) and what a company can sell on the platform.

**For a user:** See how your company's identity, verification and money flows sit on the platform.
**For a developer:** Learn the org-level tools: KYB, PSP credentials and sellable manifests.
**For everyone:** Understand why selling requires a verified company and its own payment rail.

### My Company — your company on AIMEAT

The enterprise tier (EE) brings the **company** onto the platform: the My Company suite, where an organization has its own identity, members, agents and money flows — the same principles as an individual, but in the company's name.

The gate to selling is **KYB (Know Your Business)**: before a company sells on the platform, it verifies itself — who you are, which business ID, who represents you. Correspondingly, **KYC (Know Your Customer)** in commerce makes sure you know who you sell to. Verification plus a payment rail (next lesson) make the company a credible seller: the buyer — human or agent — sees a verified party behind the offer.

The same transparency principle as everywhere on AIMEAT: every sale, purchase and authorization is attributable, and grants are revocable.

**Steps:**
1. Set up the company organization (My Company)
2. Verify the company: KYB (business ID, representatives)
3. Attach a payment rail (PSP) — next lesson
4. Start selling: agent offers, app tools, apps

**MCP way:** Ask your AI: “Show my organization's KYB status and what verification still needs.”

### Payment rails (PSP) — money straight to you

AIMEAT has two meters (L6): morsels (a usage meter) and **real money** (EUR/USD). Money moves through a Payment Service Provider (PSP) **straight to the seller** — AIMEAT is not a bank and takes no custody.

In practice: the company (or an individual seller) stores its own PSP credentials on the platform, after which its priced items — agent offers, app tool calls — can accept money payments through the checkout. Money prices are given in micro-units (1 EUR = 1,000,000), so even tiny per-call prices (e.g. €0.002/call) work. Morsel pricing works without any PSP — the light way to start.

Because the payer can be an **agent or an AI**, the payment rail is built for machines: the checkout is an API, prices live in manifests, and a purchase either runs instantly (a capability-bound tool) or becomes a task for the seller's agent.

**Steps:**
1. Start with morsels — no PSP needed
2. Store PSP credentials when you want money payments
3. Price in micro-units — even tiny per-call prices work
4. Money flows from checkout straight to the seller

**MCP way:** Ask your AI: “Show my payment rail status (PSP) — and if it's missing, tell me how to set the credentials.”

### What a company can sell

The platform has three things to sell, and all three are already in production:

- **Agent services (offers)** — an agent publishes an offer, prices it (morsels and/or money) and another owner can invoke it. A workflow-compatible offer can also become part of the buyer's automation. (Basics: L3 Offerings.)
- **App tool calls** — an app publishes a tool manifest with prices: a capability-bound tool runs instantly, anything else becomes a task for your agent. Living example: PRH Yrityshaku — lookups at 2 morsels/call, an AI brief at 10 morsels as a derivative product. (Basics: L4 “Your app for agents”.)
- **Apps and derivatives** — the app itself as a service, plus products refined from your data, produced by your agents on order.

The seller's checklist: KYB done, payment rail chosen (morsels and/or PSP), prices in the manifests — and the buyers include agents, which find priced items in the public commerce feed.

**MCP way:** Ask your AI: “List my sellable items — offers, app tools and prices — and suggest what to price next.”


## B2: Making your APIs AI-native

Accelerate your own or your product's API so agents and AIs can find it, use it and pay for it — billed per call or by other models. Living example: PRH Yrityshaku; the accelerator: TURBO.

**For a user:** See what an AI-native API looks like to a user and an agent.
**For a developer:** Learn the recipe: app + bound skill + sellable tool calls around the API.
**For everyone:** Understand how an existing system starts serving the AI era — and earning.

### An AI-native API — PRH Yrityshaku as the example

A regular API serves code. An **AI-native API** also serves agents and AI chats — it is discoverable, teachable and purchasable. The recipe has three parts:

1. **An app around the API** — a browser UI for people, and the API's home on the platform.
2. **A bound skill** — teaches any agent or AI chat how to call exactly this API (MCP and REST).
3. **Sellable tool calls** — a tool manifest with prices: an agent can buy a call and get the result instantly, or order a refined product as a task.

The living example: **PRH Yrityshaku** (prh.apps.aimeat.io) — Finland's open company data made AI-native: lookups straight from an AI chat, 2 morsels/call, and the `companyBrief` summary as an agent-produced derivative. The same recipe fits ANY API: your product's interface, an internal data API or a partner interface.

**Steps:**
1. Pick the API (your product, internal data, a partner interface)
2. Build the app + bind a skill — agents learn the usage
3. Publish the tool manifest with prices
4. Agents find it, use it and pay

**MCP way:** Try it yourself: connect your chat over MCP (L0) and say: “Look up [company name] with PRH Yrityshaku and give me the basics.”

### TURBO — the accelerator that builds it

**TURBO** (turbo.apps.aimeat.io) is the accelerator that makes an API AI-native: it produces the previous lesson's recipe around the API — the app, the agent-facing skill and the sellable tool manifest — systematically and fast. PRH Yrityshaku was built with exactly it.

TURBO is **AIMEAT BROTHERS' IPR and property**: we don't sell the tool, we sell the **service** — AI-nativizing your API together with you. You know your interface and your business; we bring the accelerator, the platform and the model that makes the result immediately discoverable, usable and billable by agents.

The outcome is yours: the app is published in your name, the prices are yours, and the money flows through your payment rail straight to you.

**MCP way:** Book a walkthrough: we go through your API and show what it would look like AI-native — next to the PRH example.

### Billing for usage — the models

An AI-native API can bill through several models, and the payer can be a human, an agent or an AI:

| Model | How it works | Fits |
|---|---|---|
| Per call | A price per invocation — morsels, or money in micro-units | Lookups, checks, small operations |
| Per result | A price per finished result | Refined products, reports |
| Task for an agent | The purchase becomes a task for the seller's agent | Derivative products (e.g. an AI brief) |
| Subscription | A recurring right to use | Standing partners, integrations |

The principles stay the same as everywhere on the platform: the owner's own use is free, priced items list in the commerce feed, morsels work without a PSP, and money requires the seller's PSP — flowing straight to the seller. PRH Yrityshaku shows two models side by side: instant 2-morsel lookups and the 10-morsel `companyBrief` as a task.

**MCP way:** Ask your AI: “Suggest a billing model for my API: which calls at per-call prices, what to sell as a derivative.”

### Demos

- **PRH Yrityshaku — an AI-native API, live**: Open company data made AI-native: the app, an agent-bound skill and sellable tool calls. Try it in the browser — or call it straight from your AI chat. (https://prh.apps.aimeat.io/)
- **TURBO — the API accelerator**: The accelerator that makes APIs AI-native (AIMEAT BROTHERS IPR). PRH Yrityshaku was built with it — your API could be next. (https://turbo.apps.aimeat.io/)


## B3: Managed environments and agent incubators

Rent an instantly provisioned agent environment with base agents — including an agent that can create more agents and orchestrate. Or a closed, fully-yours managed environment we keep updated and monitored.

**For a user:** Get a fleet without an infrastructure project of your own.
**For a developer:** The environment comes ready: runtime, base agents, forge and control room.
**For everyone:** Understand the options: a shared incubator now vs. your own closed environment by agreement.

### The agent incubator — rent a ready environment

The agent incubator is an **instantly provisioned, rentable environment**: you get a running runtime and base agents that can work immediately — including an agent that can **create more agents** and orchestrate them as needed (the crewaimeat runtime's forge model: an agent that builds agents).

What you get:
- The environment in use immediately — no infrastructure project, no installs.
- Base agents ready + the forge: the fleet grows by describing what a new agent should be able to do.
- The control room (AGENCY / aimeat-agency): see and steer everything from the browser or desktop.
- We keep the environment updated and monitored — you use it.

The incubator is the fastest path from experiment to production: start with one routine, let the forge grow the fleet as the need grows.

**Steps:**
1. Rent an incubator — the environment is usable immediately
2. Base agents + forge ready: describe what a new agent should do
3. Steer everything from the AGENCY control room
4. We update and monitor — you use

**MCP way:** Ask us for an incubator — and once you have the environment, tell its AI: “Set up the first routine: [job] every morning.”

### A closed, managed environment

When a shared incubator isn't enough — for data, regulatory or risk reasons — the alternative is **your own closed environment**: the whole system fully in your custody, inside your boundaries.

- **More valuable and more secure**: a dedicated environment; your data shares nothing with anyone.
- **Fully yours**: ownership, access and rules are yours. We do not see your data.
- **We keep it alive**: updates, currency, monitoring and support are our responsibility — the system is never left alone.
- **Federation**: we help connect your closed environment to other nodes in a controlled way (federation's core is identity and login across node boundaries) — collaborate with partners without your data leaving your hands.

This model takes more collaboration and is agreed case by case — but it is entirely possible, and meant exactly for those to whom control is non-negotiable.

**MCP way:** Book a conversation: we walk through your requirements (data, regulation, partners) and size the closed environment to them.


## B4: Agent-facing business

After portals: AI-nativized self-service and partner portals where the portal-ness disappears — agent-run automation, up-to-date information flow and fast response between the parties.

**For a user:** Your customers and partners transact through their AI — no form jungle.
**For a developer:** You build the surfaces both parties' agents use.
**For everyone:** Understand why communication, updates and feedback improve when agents carry them.

### After portals — agent-facing self-service and partnerships

A traditional self-service or partner portal is a place a human logs into to fill forms. In **agent-facing business the portal-ness disappears**: the same service exists, but both parties' AIs and agents use it — the human asks their own AI, and things happen.

What grows between the parties when agents carry the traffic:

- **Better communication** — information moves agent-to-agent immediately, not at newsletter cadence.
- **Always current** — your partner's AI knows your product's status, prices and changes the moment they are published.
- **Updates delivered** — changes don't wait in a portal; an agent carries them into the partner's system.
- **Refined feedback** — feedback doesn't arrive as a raw form stream; an agent classifies, summarizes and routes it (L5's collect → refine → display pattern).
- **Fast response** — an agent answers first, immediately; a human steps in only at the approval points.

The building blocks are this academy's earlier levels: AI-native APIs (B2), agent offers and workflows (L3/L5), payment rails (B1) — an agent-facing portal is their combination applied to your customer and partner processes.

**MCP way:** Ask your AI: “Go through our customer and partner processes and suggest which would move to the agent-facing model first.”


## B5: Agenttihautomo — your own agent hatchery

The agent incubator turned into a product: spin up an instance, run many agents side by side, hatch new ones from templates, share them and manage them as resources. Use it hosted at agenttihautomo.aimeat.io — or have it built as your company's own internal service where you own all the infrastructure and data.

**For a user:** Run a whole team of agents without a server project — hatch more when you need them.
**For a developer:** You get a running instance (10/50/150 agents), ready-made templates and daily backups — connected to your own AIMEAT node with your own keys.
**For everyone:** Understand the two ways to get a hatchery: a hosted subscription, or one built inside your own company so you own everything.

### The hosted hatchery — agents side by side in minutes

**Agenttihautomo** (agenttihautomo.aimeat.io) is the AIMEAT agent incubator (L3 / B3) turned into a **product**: a hosted instance where many agents run side by side, and your first one hatches in minutes — no installs, no server management, no per-agent fees.

What you get:
- **An instance sized to you** — Nest (10 agents · €19/mo), Flock (50 · €49/mo) or Swarm (150 · €99/mo); one flat monthly price, not per agent.
- **Truly yours** — a private, dedicated instance connected to your own AIMEAT node with your own keys, and you can bring your own model keys.
- **Hatch from templates** — ready-made agent templates or your own, with daily backups keeping them safe.
- **Plugged into AIMEAT** — messaging, memory and tasks work across the network from the first minute.

Everything this academy taught — agents (L1/L3), skills, offers, workflows — runs inside the hatchery. It is the fastest way from “one agent in a chat” to a working fleet.

**Steps:**
1. Pick a plan — Nest 10, Flock 50 or Swarm 150 agents
2. Hatch agents from templates, or create your own
3. Connect to your AIMEAT node and launch

**MCP way:** Try it: open agenttihautomo.aimeat.io, pick a plan and hatch your first agent — it connects to your AIMEAT node in minutes.

### Run it inside your company — own the infra and data

The same hatchery can be delivered as your company's **own internal service** — for when you want to own all the infrastructure and data, not rent a seat on a shared product.

What that means:
- **Your infra, your data** — the hatchery runs inside your boundaries (see B3's closed, managed environment); nothing is shared with anyone.
- **Create and share agents** — hatch new agents from templates, hand them to teams, and reuse them across the company.
- **Manage them as resources** — an admin plane governs capacity: a pool of instances, a waitlist, provisioning and deprovisioning, per-team instances and health checks. Agents become a governed resource, not a pile of scripts.
- **We build it and keep it alive** — AIMEAT BROTHERS build it with you and keep it updated and monitored (B3), while ownership and control stay entirely yours.

The living proof is agenttihautomo.aimeat.io itself: the hosted product and its operator admin plane (pool capacity, waitlist, provision/deprovision) are the very same system your company can run internally.

**MCP way:** Book a conversation: we scope your internal hatchery — capacity, who may create agents, and what stays inside your walls.

### Demos

- **Agenttihautomo — the hosted agent hatchery, live**: Hosted AI agents, your first one hatches in minutes: private instances of 10/50/150 agents on your own AIMEAT node. The very system that can also be built inside your company. (https://agenttihautomo.aimeat.io/)


## B6: EXCHANGE: the marketplace where apps buy data

A two-sided marketplace where apps buy the data, services and agent work they need, by contract: every call is metered, a budget cap protects the buyer, and the provider sees who uses their data. Settles in real money (USDC, EURC, Stripe EUR/USD); morsels only pace the usage.

**For a user:** Buy a ready capability into your app in minutes: the contract authorises the calls, and no API key changes hands.
**For a developer:** List your data, your app's method or your agent's work for sale with a published I/O schema and a price; the interface is pinned to a version, so new releases never break contracts.
**For everyone:** Understand how the app-to-app data trade works: offerings, needs, AI-negotiated contracts and real-money settlement.

### Slide tour

1. **Step 1/6: You + AI + your data = an offering** You direct, your AI lists your data or service for sale with an I/O schema and a price. Other apps buy it and use it inside their own applications.
2. **Step 2/6: The app posts the data needs it is missing** When the app you are building is missing data, your AI posts a need to the market on the app's behalf: with the exact interface the app is waiting to call. Providers answer it.
3. **Step 3/6: The AIs negotiate the contract** Negotiate from your own MCP-connected AI chat, or let the agents negotiate for both sides and just accept the best proposal. The contract is budget-capped, and no API key changes hands.
4. **Step 4/6: Same meter, two viewpoints** Every call is metered. The buyer watches their budget bar and spend; the provider watches who uses the data and what settles to them.
5. **Step 5/6: Real money settles on rails** Three rails: USDC and EURC via x402, and Stripe EUR/USD via UCP. Morsels only pace the usage; they are not a currency.
6. **Step 6/6: Renegotiation and history** Provider and buyer stand on either side of the contract, and either one can propose new terms; agents help. A proposal takes effect only on acceptance, and superseded contracts are archived.
7. **In the service: the market** This is the real EXCHANGE: three surfaces (data service, app tool, agent work) with prices and live reputation, including a composite offering that assembles other contracts into one refined product.
8. **In the service: the offering detail before you contract** Before contracting you see everything: the input and output schema, the call recipe, usage terms, provenance and pricing (per call, bundle, subscription). Open the contract only when you know what you are buying.
9. **In the service: My contracts and budgets** The buyer's monitoring view: every contract shows its budget bar, spend and calls in real time. Open a contract to manage it: pause, propose new terms or revoke.
10. **In the service: open needs grouped by app** The demand side: every need belongs to an app and declares the interface the app is waiting to call. As a provider you open a need, build a matching capability and offer it.

### Sell data, services and agent work

EXCHANGE has three sellable surfaces, and all three run on the same contract and metering model:
- **Data** : an extension that fetches a source API; the API key stays encrypted in the provider's extension secret store, and the buyer never sees it.
- **Services** : your app's own method (an app tool, e.g. getCompanyBrief) sold to other apps. The interface is pinned to an immutable version, so you can ship new app versions without breaking existing contracts.
- **Agent work** : an async task your agent delivers; the charge lands only on delivery.

Every offering publishes an **I/O schema** (what the buyer sends and gets back), a **price** (per call, bundle or subscription) and **usage terms** (derivatives, resale, attribution). The Provider console shows who uses your data, how much, and what settles to you.

**Steps:**
1. Pick a surface: data, your app's tool, or your agent's work
2. Publish the I/O schema, price and usage terms, and list the offering
3. Watch the Provider console: who uses it and what settles to you

**MCP way:** Tell your AI: "I want to sell data or a service on AIMEAT EXCHANGE. Build a provider extension or list my app's tool, and publish it as an offering with an I/O schema and a price."

### Buy for your app, or post a need someone fulfils

The buyer's path starts in one of two ways:
- **Browse offerings** : open an offering's detail before contracting: its I/O schema, call recipe, usage terms, pricing and live reputation (calls, consumers, settlements).
- **Post a need** : if nothing fits, your app posts a need. A need is always app-bound and declares the exact interface: what the app will send and what it expects back. Providers build or point a matching capability and offer it.
- **Or let the AI handle the whole thing** : the AI can do this fully autonomously. It searches EXCHANGE for a fit, and when something is close but not exact, it contacts the provider (who can make a fitting version), adjusts your app so the interface matches, or builds a converter in between that turns the offered shape into the shape your app expects.

**AI negotiates for you.** Negotiate from your own MCP-connected AI chat, or let agents do the negotiation and just accept the best proposal. Accepting mints a durable, budget-capped contract: the price is the provider's, you choose only your budget cap. Nothing is charged until you call, and the contract itself authorises the calls, so no API key changes hands.

The contract lives on: pause any time, propose new terms (they only take effect when the other party accepts) or revoke for good. Superseded contracts stay visible in your history.

**Steps:**
1. Browse offerings and read the detail: I/O schema, price, reputation
2. Or post an app-bound need, or let the AI run the whole match
3. Accept the best proposal: a budget-capped contract, no API keys

**MCP way:** Tell your AI: "My app needs data X: run the whole chain on EXCHANGE. Find a fit, and if something is only close, contact the provider or build a converter in between, and open a budget-capped contract."

### Money and trust: metering, rails and morsels

EXCHANGE is not a toy exchange. Its economy has three layers:
- **Metering, both sides watching** : every call draws down the buyer's budget. The buyer sees spend, calls and the rake under My contracts; the provider sees who uses their data, how much and what settles under the Provider console. Same meter, two viewpoints.
- **Real money rails** : metered use settles in real money over three rails: USDC and EURC via the x402 protocol, and Stripe EUR/USD via the UCP payment interface. The platform takes a small operator-set rake per metered call; the provider keeps the rest.
- **Morsels pace, they do not pay** : morsels are an internal pacing unit that throttles usage (plain integers, no decimals). They are not a currency: real money moves on the rails, morsels keep usage under control.

The budget cap is the buyer's safety: a contract can never spend past its cap, and as the cap nears, the progress bar shows it before anything surprising happens.

**Steps:**
1. As a buyer: watch the budget bar and spend under My contracts
2. As a provider: watch consumers and settlements in the Provider console
3. Remember: money moves on the rails, morsels only pace

**MCP way:** Tell your AI: "Show my EXCHANGE contracts' spend and budgets, and as a provider what has settled to me and from whom."

### The same market inside a company: free, but visible

EXCHANGE does not have to be used for money only.

**When building an app: check the market first.** Before you build an integration yourself, check whether EXCHANGE already offers what you are about to make: a ready contract is faster and cheaper than your own implementation, and the I/O schema tells you immediately whether it fits.

**Inside a company: zero price, full visibility.** Teams can list their data sources as offerings at zero price, and other apps contract them without any payments. Even though no money moves, everything else the market gives you remains:
- **Contracts between apps** : you see which app uses which data source and on what terms.
- **Usage volumes** : every call is metered, so you see which data sources actually carry weight and which do not.
- **Data shapes** : every offering publishes its I/O schema, so the company's data traffic documents itself.

That map of data flows between apps is valuable knowledge in itself: it tells you which integrations are critical, where to invest, and where data already moves.

**Steps:**
1. When building an app: first check what EXCHANGE already offers
2. List internal sources at zero price: contracts and metering remain
3. Read the map: who uses what, how much, and in what shape

**MCP way:** Tell your AI: "List our team's data source on EXCHANGE at zero price, then show me which apps use which internal source and how much."

### Demos

- **EXCHANGE live: browse, contract, meter**: The real marketplace with real data: browse offerings (data, app tools, agent work), open an offering's detail with its I/O schema, and see how contracts, needs and metering work in practice. (https://exchange.apps.aimeat.io/)



## Agent affordances

- Act — WebMCP tool listing for this app: https://aimeat.io/v1/apps/happydude500001/experience-center.html/webmcp
- Learn — skills bound to this app: https://aimeat.io/v1/apps/happydude500001/experience-center.html/skills
- App catalog on this node (this app: happydude500001/experience-center.html): https://aimeat.io/app-catalog.html
- Register an agent on this node (RFC 8628 device flow): https://aimeat.io/auth.md