--- title: "Co to jest stos AI native? Poradnik dla firm" url: "https://majchrzycki.com/blog/co-to-jest-stos-ai-native-poradnik-dla-firm" description: "Czym jest aplikacja AI native, z jakich warstw składa się jej stos, kiedy wystarczy gotowy czat jak Open WebUI, a kiedy budować własny interfejs." --- # Co to jest stos AI native? Poradnik dla firm 6 października 2026· Aktualizacja: 6 października 2026·8 min czytania·[Krzysztof Majchrzycki](https://majchrzycki.com/o-mnie) Temat: [Open Source AI](https://majchrzycki.com/blog/filar/open-source-ai) **Stos AI native to zestaw warstw, z których buduje się aplikację z modelem AI w środku procesu, a nie obok niego: interfejs, protokół między agentem a ekranem, backend agenta oraz modele i narzędzia.** Taka aplikacja pokazuje odpowiedź na bieżąco, wywołuje narzędzia, zatrzymuje się po zatwierdzenie człowieka i trzyma stan agenta widoczny obok danych. Gotowy czat, np. Open WebUI, wystarcza do rozmowy z modelami i dokumentami. Własny interfejs ma sens, gdy agent ma zmieniać dane w Waszych systemach, a człowiek musi widzieć, co zatwierdza. Poradnik jest dla lidera IT, architekta i zarządu firmy od 50 osób, która z pilotażu czatu przechodzi do aplikacji z agentem. Czym jest sam agent, opisuje [poradnik „Co to jest agent AI”](https://majchrzycki.com/blog/co-to-jest-agent-ai-poradnik-dla-firm), a jak agent łączy się z narzędziami — [poradnik o MCP i protokołach agentów](https://majchrzycki.com/blog/co-to-jest-mcp-poradnik-dla-firm). Na końcu jest mapa wszystkich wpisów o stosie AI native na blogu. Stan wszystkich informacji: 6.10.2026. ## Aplikacja AI native, czyli AI w środku procesu Większość firm zaczyna od okna czatu: pracownik pyta, model odpowiada, a reszta pracy dzieje się jak dawniej. To asystent obok procesu. Aplikacja AI native jest projektowana od początku wokół tego, że część kroków wykonuje model. Różnicę widać w czterech cechach. Cecha Co widzi użytkownik Czego wymaga od stosu Strumieniowanie odpowiedź i kolejne kroki pojawiają się na bieżąco, nie po minucie ciszy transportu zdarzeń (np. SSE, WebSocket) i interfejsu, który składa je w całość Narzędzia agent czyta i zapisuje dane w CRM, ERP, bazie zgłoszeń backendu agenta z listą narzędzi, uprawnieniami i dziennikiem Człowiek w pętli przed skutkiem pojawia się karta „zatwierdź / popraw / odrzuć” przerwania w przebiegu agenta i wznowienia po decyzji Stan agenta w interfejsie widać, nad czym agent pracuje, co już zmienił i co tylko proponuje wspólnego stanu agenta i ekranu, synchronizowanego w obie strony Agent bez strumieniowania przypomina kolegę, który mówi „już kończę” i znika na kwadrans. Użytkownik, który przez długą chwilę nie wie, co robi agent, zamyka kartę albo — gorzej — klika „zatwierdź” bez czytania. Ta sama logika obowiązuje w gotowych platformach vendorów. Microsoft opisuje aplikacje AI native na Azure, a wpis [Aplikacje AI native w Microsoft Azure](https://majchrzycki.com/blog/microsoft-intelligent-ai-native-applications-microsoft-azure) pokazuje, które usługi za tym stoją. Ten poradnik dotyczy otwartego stosu, który firma składa i utrzymuje sama albo z partnerem. ## Cztery warstwy stosu AI native Najprościej czytać stos od ekranu w dół. Każda warstwa ma inne pytanie do rozstrzygnięcia i inną osobę, która za nie odpowiada. 1. **Interfejs.** To, co widzi człowiek: wątek rozmowy, karty zatwierdzeń, tabela z danymi, formularz z propozycją agenta. Zwykle React albo inny framework webowy plus biblioteka komponentów (shadcn/ui, Radix UI, Base UI) i design system. Pytanie: czy użytkownik odróżnia propozycję od wykonanego działania? 2. **Protokół agent–interfejs.** Kontrakt, którym agent przesyła na ekran tekst, wywołania narzędzi, stan i prośby o decyzję. Otwartym standardem jest tu AG-UI. Pytanie: czy można wymienić backend agenta bez przepisywania ekranu? 3. **Backend agenta.** Framework, który prowadzi przebieg: LangGraph, Microsoft Agent Framework, Mastra, własny kod na Vercel AI SDK. Tu żyją reguły, pamięć, limity i dziennik. Pytanie: gdzie zapisuje się, co agent zrobił i kto to zatwierdził? 4. **Modele i narzędzia.** Model językowy (w chmurze vendora albo własny) oraz narzędzia i dane firmy, podłączone np. przez MCP. Pytanie: do czego agent ma dostęp i z czyimi uprawnieniami? Pod tymi warstwami działa jeszcze zaplecze wytwarzania: TypeScript i Zod pilnują kontraktów danych, Vitest i Playwright testują ścieżkę użytkownik–agent, a pnpm, Nx czy Turborepo porządkują repozytorium. To ono decyduje, czy aplikację da się bezpiecznie zmieniać co tydzień. Szerzej o tej części piszę w poradniku o AI SDLC, a o całej infrastrukturze otwartego stosu — w [poradniku „Co to jest AI OS”](https://majchrzycki.com/blog/co-to-jest-ai-os-poradnik-dla-firm). Warstwy aplikacji AI native od ekranu w dół: interfejs (React, komponenty, design system), protokół agent–interfejs (AG-UI: strumień, narzędzia, stan, przerwania), backend agenta (framework, reguły, pamięć, dziennik) oraz modele i narzędzia (model językowy, MCP, dane firmy). Uprawnienia i zatwierdzenia przechodzą przez wszystkie warstwy. Cztery warstwy aplikacji AI native i pytanie, które rozstrzyga każda z nich. Opracowanie autora na podstawie dokumentacji AG-UI, CopilotKit i Vercel AI SDK. ## AG-UI: kontrakt między agentem a ekranem [AG-UI](https://docs.ag-ui.com/introduction) to według dokumentacji otwarty, lekki protokół oparty na zdarzeniach, który standaryzuje połączenie agentów z aplikacjami użytkownika. Działa nad HTTP i WebSocket. Projekt powstał ze współpracy CopilotKit z LangChain i CrewAI, a dokumentacja wymienia integracje m.in. z LangGraph, CrewAI, Microsoft Agent Framework, Google ADK, AWS Strands Agents, Mastra, Pydantic AI i Claude Agent SDK. Protokół opisuje [kategorie zdarzeń](https://docs.ag-ui.com/concepts/events): cykl życia przebiegu (start, kroki, koniec, błąd), wiadomości tekstowe w częściach, wywołania narzędzi z argumentami i wynikiem, migawki i zmiany stanu, a także aktywność, subagentów i rozumowanie. Dla firmy najważniejsze jest przerwanie: przebieg kończy się wynikiem „interrupt”, interfejs pokazuje decyzję do podjęcia, a agent rusza dalej dopiero po odpowiedzi człowieka. Stan na 6.10.2026: repozytorium [ag-ui-protocol/ag-ui](https://github.com/ag-ui-protocol/ag-ui) ma licencję MIT, pakiety `@ag-ui/core` i `@ag-ui/client` są w wersji 1.0.2 (5.10.2026), a nowe wydania pojawiają się niemal codziennie. W Microsoft Agent Framework integracja AG-UI ma status preview. Wniosek dla architektury: AG-UI nie zastępuje MCP ani A2A. MCP łączy agenta z narzędziami, A2A z innym agentem, AG-UI z człowiekiem. Żaden z nich nie decyduje, co agentowi wolno — to wciąż sprawdza serwer. ## Biblioteki interfejsu: z czego składa się ekran Nad protokołem są biblioteki, które oszczędzają zespołowi pisania tych samych elementów: wątku rozmowy, strumieniowania, kart narzędzi i zatwierdzeń. Trzy najczęściej spotykane w otwartym stosie (stan na 6.10.2026): Projekt Rola Licencja Wersja (data) [CopilotKit](https://github.com/CopilotKit/CopilotKit) agent osadzony w aplikacji: generatywne UI, wspólny stan, człowiek w pętli; React, Angular, Vue, React Native; zbudowany na AG-UI MIT 1.77.0 (2.10.2026) [assistant-ui](https://github.com/assistant-ui/assistant-ui) komponenty czatu dla Reacta: wątek, strumieniowanie, wywołania narzędzi jako komponenty, karty zatwierdzeń, dostępność MIT `@assistant-ui/react` 0.15.25 (6.10.2026) [Vercel AI SDK](https://ai-sdk.dev/docs/introduction) zestaw TypeScript: jedno API do wielu vendorów modeli, narzędzia, agenci (Core) oraz hooki czatu (UI) dla Reacta, Next.js, Vue i Svelte Apache 2.0 `ai` 7.0.128 (5.10.2026) Każdy z nich rozwiązuje inną część. CopilotKit pasuje, gdy agent ma działać w istniejącym ekranie procesu, np. obok formularza zamówienia. assistant-ui daje dopracowany wątek rozmowy, który zespół składa z prymitywów. AI SDK łączy backend z modelami i dostarcza hooki, na których można zbudować własny interfejs. Wersje poniżej 1.0 (assistant-ui) i tempo wydań (CopilotKit wydał kilka wersji w tydzień) oznaczają, że aktualizacje trzeba zaplanować, a nie robić „przy okazji”. Niżej leży zwykły frontend: React (19.3.0 z 9.09.2026), Next.js (16.3.8 z 30.09.2026), komponenty Radix UI, Base UI i shadcn/ui, Tailwind CSS, TanStack Table do tabel z danymi agenta. Wpisy w mapie poniżej opisują każdy z nich w tym samym układzie: rola, alternatywy, ograniczenia i próba w projekcie. Design system (Material, Fluent, Carbon) warto wybrać przed pierwszym ekranem, bo stany błędu i niepewności AI muszą wyglądać spójnie w całej aplikacji. ## Gotowy czat czy własny interfejs? [Open WebUI](https://docs.openwebui.com/) to gotowa, samodzielnie hostowana aplikacja czatu. Według dokumentacji działa offline, łączy się z Ollama i API zgodnymi z OpenAI, ma RAG, role z grupami, SSO, LDAP i SCIM oraz obsługę narzędzi i serwerów MCP. Dla wielu firm to najkrótsza droga do wspólnego, kontrolowanego czatu z modelami i dokumentami. Jest jedno zastrzeżenie, które firmy od 50 osób powinny przeczytać przed wdrożeniem. [Licencja Open WebUI](https://github.com/open-webui/open-webui/blob/main/LICENSE) (wersja 0.11.4, stan na 6.10.2026) zabrania zmiany lub usunięcia brandingu „Open WebUI”, chyba że wdrożenie ma nie więcej niż 50 użytkowników końcowych w kroczącym okresie 30 dni, jest pisemna zgoda autora albo licencja enterprise. Jeśli planujecie firmowego asystenta z własnym logo, warunki licencji oceni prawnik. Własny interfejs kosztuje więcej pracy, ale jest konieczny, gdy agent działa w procesie, a nie w rozmowie. Proponuję cztery pytania (uproszczenie autora): 1. **Czy agent ma zmieniać dane w systemach firmy?** Jeśli tylko odpowiada i streszcza — gotowy czat zwykle wystarczy. 2. **Czy człowiek zatwierdza działanie, widząc dane przed i po?** Jeśli tak — potrzebny jest ekran procesu z kartą zatwierdzenia, nie okno czatu. 3. **Czy wynik ma trafić do istniejącej aplikacji (CRM, panel zamówień)?** Jeśli tak — osadźcie agenta w tej aplikacji (np. CopilotKit, assistant-ui). 4. **Czy branding, licencja i liczba użytkowników pasują do gotowego produktu?** Jeśli nie — własny interfejs na bibliotekach z licencją MIT lub Apache 2.0. Karta decyzji „Gotowy czat czy własny interfejs?”. Cztery pytania: czy agent zmienia dane w systemach, czy człowiek zatwierdza działanie widząc dane przed i po, czy wynik trafia do istniejącej aplikacji, czy branding i licencja pasują do gotowego produktu. Odpowiedzi prowadzą do gotowego czatu (np. Open WebUI), agenta osadzonego w aplikacji albo własnego interfejsu. Uproszczenie autora. Gotowy czat czy własny interfejs: cztery pytania przed wyborem. Uproszczenie autora na podstawie dokumentacji i licencji projektów, stan na 6.10.2026. Rozsądna ścieżka bywa dwuetapowa: gotowy czat dla całej firmy do pracy z wiedzą i osobna aplikacja z agentem dla jednego procesu, w którym liczy się zapis w systemie. ## Ryzyka: bezpieczeństwo, koszt i niepewność **Bezpieczeństwo.** Interfejs jest ostatnim miejscem, w którym człowiek może zatrzymać błąd, ale nie miejscem, w którym działa kontrola dostępu. [OWASP Top 10 for LLM Applications 2025](https://genai.owasp.org/llm-top-10/) wskazuje trzy ryzyka szczególnie ważne dla tej warstwy: wstrzyknięcie poleceń (LLM01) — także przez treść dokumentu czy strony, którą agent czyta; niewłaściwą obsługę wyniku modelu (LLM05) — np. wyświetlenie wygenerowanego HTML bez oczyszczenia; oraz nadmierną sprawczość (LLM06) — agenta z szerszymi uprawnieniami, niż wymaga zadanie. Ukrycie przycisku w interfejsie nie odbiera agentowi uprawnienia. Sprawdzenie musi być po stronie serwera. **Koszt.** Biblioteki są open source, ale aplikacja nie. Płacicie za pracę zespołu, utrzymanie przy częstych wydaniach, hosting i zużycie modeli. OWASP opisuje osobno nieograniczone zużycie zasobów (LLM10): agent w pętli albo użytkownik wklejający całe repozytorium potrafią szybko zużyć budżet. Limity na rozmowę, użytkownika i dzień ustawcie przed pierwszym pilotażem. **UX niepewności.** Model mówi tym samym pewnym tonem, gdy ma rację i gdy jej nie ma. [Wytyczne Microsoft Research z CHI 2019](https://www.microsoft.com/en-us/research/publication/guidelines-for-human-ai-interaction/) (18 zasad interakcji człowieka z AI) zalecają m.in. jasno pokazać, co system potrafi i jak dobrze, oraz umożliwić szybką korektę. W aplikacji z agentem oznacza to: propozycja wygląda inaczej niż wykonana zmiana, źródła są widoczne, a „odrzuć” jest tak samo łatwe jak „zatwierdź”. **Dojrzałość projektów.** Część stosu zmienia się co tydzień, a niektóre elementy są jeszcze przed wersją 1.0 albo w fazie kandydata do wydania (Cordis 4.0.0-rc.10 z 8.09.2026). Przypnijcie wersje, prowadźcie rejestr zależności i miejcie test, który po aktualizacji sprawdzi całą ścieżkę: od pytania użytkownika do zatwierdzonego zapisu. ## Jak zacząć: jeden proces, jeden ekran, jedna próba 1. **Wybierzcie proces, w którym agent ma coś zmienić,** np. przygotowanie korekty zamówienia do zatwierdzenia. Zapiszcie, co agent może zrobić sam, a co zatwierdza człowiek. 2. **Zdecydujcie: gotowy czat czy własny ekran** — według czterech pytań z karty powyżej. 3. **Narysujcie ekran zatwierdzenia przed kodem:** dane przed i po, źródła, przyciski zatwierdź, popraw, odrzuć. 4. **Zbudujcie cienką ścieżkę przez wszystkie warstwy:** interfejs, AG-UI albo strumień AI SDK, backend agenta z jednym narzędziem i dziennikiem. 5. **Przetestujcie awarie:** zerwanie połączenia w połowie wywołania narzędzia, odmowę użytkownika, przekroczenie limitu kosztu. Interfejs nie może pokazać propozycji jako wykonanej zmiany. 6. **Zapiszcie decyzję architektoniczną:** wybrane biblioteki i wersje, licencje, właściciel utrzymania, warunek wymiany. Taką aplikację najlepiej buduje inżynier, który rozumie zarówno proces klienta, jak i warstwy stosu. Tego uczy [kurs Forward Deployed AI Engineer](https://majchrzycki.com/akademia/kurs-forward-deployed-ai-engineer) w Akademii — od rozmowy z właścicielem procesu po odbiór działającej aplikacji. Niezależnie od vendora i partnera. ## Mapa wpisów o stosie AI native Wszystkie wpisy na blogu o warstwach aplikacji AI native, pogrupowane od agenta do zaplecza wytwarzania. ### A. Agent na ekranie: protokół i gotowe interfejsy - [AG-UI: otwarty kontrakt między agentem a ekranem](https://majchrzycki.com/blog/technologia-ag-ui-ai-native) — zdarzenia między agentem a interfejsem. - [CopilotKit: interfejs człowiek–agent w aplikacji](https://majchrzycki.com/blog/technologia-copilotkit-ai-native) — agent osadzony w ekranie procesu. - [Open WebUI: własny interfejs do modeli AI](https://majchrzycki.com/blog/technologia-open-webui-ai-native) — gotowy, samodzielnie hostowany czat. - [Cordis: kompozycja usług dla agentów AI](https://majchrzycki.com/blog/technologia-cordis-ai-native) — składanie usług i pluginów z kontrolą zakresu. - [Aplikacje AI native w Microsoft Azure](https://majchrzycki.com/blog/microsoft-intelligent-ai-native-applications-microsoft-azure) — ten sam wzorzec na platformie vendora. ### B. Interfejs: React i komponenty - [React w aplikacjach AI: stan rozmowy i działania](https://majchrzycki.com/blog/technologia-react-ai-native) - [React Router: czytelna nawigacja w produkcie AI](https://majchrzycki.com/blog/technologia-react-router-ai-native) - [React Hook Form: formularz pod kontrolą człowieka](https://majchrzycki.com/blog/technologia-react-hook-form-ai-native) - [shadcn/ui w aplikacji AI: kod pod kontrolą zespołu](https://majchrzycki.com/blog/technologia-shadcn-ui-ai-native) - [Radix UI: dostępne prymitywy dla interfejsu AI](https://majchrzycki.com/blog/technologia-radix-ui-ai-native) - [Base UI: własny wygląd i dostępne interakcje AI](https://majchrzycki.com/blog/technologia-base-ui-ai-native) - [Tailwind CSS w systemie AI: szybki, spójny interfejs](https://majchrzycki.com/blog/technologia-tailwind-css-ai-native) - [Lucide React: czytelne ikony w aplikacji AI](https://majchrzycki.com/blog/technologia-lucide-react-ai-native) - [TanStack Table: kontrola danych w tabeli agenta](https://majchrzycki.com/blog/technologia-tanstack-table-ai-native) - [dnd-kit: przenoszenie zadań agenta pod kontrolą](https://majchrzycki.com/blog/technologia-dnd-kit-ai-native) ### C. Design systemy dla aplikacji AI - [Design system dla aplikacji AI: jak wybrać](https://majchrzycki.com/blog/open-source-design-systems-ai-apps) — Material, Carbon i Fluent na tych samych zadaniach. - [Material Design w aplikacji AI: kryteria wyboru](https://majchrzycki.com/blog/google-material-design-system-ai-apps) - [Fluent Design w aplikacji AI: czytelność i kontrola](https://majchrzycki.com/blog/microsoft-fluent-design-system-ai-apps) ### D. Runtime, backend i dane aplikacji - [Node.js w suwerennym systemie AI: rola runtime](https://majchrzycki.com/blog/technologia-nodejs-ai-native) - [Next.js dla aplikacji AI: kiedy pełny framework pomaga](https://majchrzycki.com/blog/technologia-nextjs-ai-native) - [Awilix: wymiana zależności w backendzie agenta](https://majchrzycki.com/blog/technologia-awilix-ai-native) - [Drizzle ORM: jawne dane aplikacji agentowej](https://majchrzycki.com/blog/technologia-drizzle-orm-ai-native) - [PostHog: pomiar użycia AI z kontrolą danych](https://majchrzycki.com/blog/technologia-posthog-ai-native) ### E. Kontrakty, testy i jakość kodu - [TypeScript: kontrakty dla suwerennej aplikacji AI](https://majchrzycki.com/blog/technologia-typescript-ai-native) - [Zod: walidacja danych na granicy agenta AI](https://majchrzycki.com/blog/technologia-zod-ai-native) - [Vitest: szybkie testy jednostek i kontraktów AI](https://majchrzycki.com/blog/technologia-vitest-ai-native) - [Playwright: test całej ścieżki użytkownik–agent](https://majchrzycki.com/blog/technologia-playwright-ai-native) - [ESLint jako bramka zmian od agenta kodującego](https://majchrzycki.com/blog/technologia-eslint-ai-native) - [Prettier: mniej szumu w zmianach pisanych przez AI](https://majchrzycki.com/blog/technologia-prettier-ai-native) ### F. Budowanie i monorepo - [Vite: krótka pętla pracy nad interfejsem AI](https://majchrzycki.com/blog/technologia-vite-ai-native) - [pnpm: powtarzalne zależności dla agentów kodujących](https://majchrzycki.com/blog/technologia-pnpm-ai-native) - [Corepack: wersja menedżera pakietów pod kontrolą](https://majchrzycki.com/blog/technologia-corepack-ai-native) - [Nx w AI SDLC: graf projektów i zakres zmian](https://majchrzycki.com/blog/technologia-nx-ai-native) - [Turborepo: szybki feedback w monorepo AI](https://majchrzycki.com/blog/technologia-turborepo-ai-native) ### Poradniki powiązane - [Co to jest agent AI?](https://majchrzycki.com/blog/co-to-jest-agent-ai-poradnik-dla-firm) — czym agent różni się od bota i asystenta. - [Co to jest MCP?](https://majchrzycki.com/blog/co-to-jest-mcp-poradnik-dla-firm) — protokoły agentów: MCP, A2A, AG-UI. - [Co to jest AI OS?](https://majchrzycki.com/blog/co-to-jest-ai-os-poradnik-dla-firm) — infrastruktura otwartego, suwerennego stosu. - [Co to jest AI SDLC?](https://majchrzycki.com/blog/co-to-jest-ai-sdlc-poradnik-dla-firm) — wytwarzanie oprogramowania z agentami. - Open Source AI - Agenci AI - AI SDLC - Bezpieczeństwo ## Zbuduj interfejs, w którym człowiek kontroluje agenta Forward Deployed AI Engineer to kurs w Akademii dla inżyniera, który projektuje z firmą aplikację z agentem: od interfejsu i zatwierdzeń po narzędzia i odbiór. Kurs jest w przygotowaniu — zapisz się na listę oczekujących. [Zobacz kurs Forward Deployed AI Engineer](https://majchrzycki.com/akademia/kurs-forward-deployed-ai-engineer) FAQ ## Najczęstsze pytania Czym aplikacja AI native różni się od aplikacji z dodanym czatem? W aplikacji z dodanym czatem model odpowiada w osobnym oknie, a proces działa po staremu. W aplikacji AI native model pracuje w środku procesu: korzysta z narzędzi, pokazuje kolejne kroki na bieżąco, prosi człowieka o zatwierdzenie przed skutkiem, a jego stan jest widoczny w interfejsie obok danych, na których pracuje. Czy AG-UI zastępuje MCP? Nie. Według dokumentacji AG-UI te protokoły obsługują różne granice: MCP łączy agenta z narzędziami i danymi, A2A agenta z innym agentem, a AG-UI agenta z interfejsem użytkownika. W jednej aplikacji często działają wszystkie trzy. Czy Open WebUI wystarczy na start w firmie od 50 osób? Często tak, jeśli celem jest wspólny czat z modelami, dokumentami i prostymi narzędziami. Sprawdźcie jednak licencję używanej wersji: według pliku LICENSE z 6.10.2026 zmiana albo usunięcie brandingu Open WebUI przy ponad 50 użytkownikach w 30 dni wymaga zgody autora albo licencji enterprise. Ocenę warunków zostawcie prawnikowi. Czy do własnego interfejsu agenta potrzebny jest React? Nie musi, ale większość bibliotek interfejsu dla agentów zaczyna od Reacta: CopilotKit, assistant-ui i hooki Vercel AI SDK. CopilotKit obsługuje też Angular i Vue, a AI SDK — m.in. Vue i Svelte. Wybór frameworka warto oprzeć na tym, co zespół już utrzymuje. Ile kosztuje aplikacja AI native? Nie ma jednej ceny. Biblioteki opisane w poradniku mają licencje open source (MIT, Apache 2.0, a Open WebUI własną), więc główny koszt to praca zespołu, utrzymanie przy częstych wydaniach, hosting i zużycie modeli. Porównujcie warianty na jednym procesie, z limitem kosztu na rozmowę i na użytkownika. Jak pokazać użytkownikowi, że model może się mylić? Interfejs powinien mówić, co system potrafi i jak dobrze, pokazywać źródła i kroki agenta oraz pozwalać szybko poprawić wynik — to wytyczne Microsoft Research z CHI 2019. W praktyce: propozycja wygląda inaczej niż wykonana zmiana, a każde działanie ze skutkiem ma przycisk zatwierdzenia i odmowy. Kto w firmie powinien budować taką aplikację? Zespół, który łączy znajomość procesu z inżynierią: właściciel procesu określa, co agent może zrobić bez pytania, inżynier buduje interfejs, integracje i testy, a IT odpowiada za tożsamość, uprawnienia i dzienniki. Sam frontend bez właściciela procesu daje ładny czat, który niczego nie zmienia. ## Czytaj dalej - [AG-UI: otwarty kontrakt między agentem a ekranem](https://majchrzycki.com/blog/technologia-ag-ui-ai-native) - [Co to jest MCP? Protokoły agentów AI — poradnik dla firm](https://majchrzycki.com/blog/co-to-jest-mcp-poradnik-dla-firm) - [Radix UI: dostępne prymitywy dla interfejsu AI](https://majchrzycki.com/blog/technologia-radix-ui-ai-native) - [React w aplikacjach AI: stan rozmowy i działania](https://majchrzycki.com/blog/technologia-react-ai-native)