AI United College

Prof Zoran Jovičić podkast i blog

Priručnik za AGENTIK automatizaciju procesa uz pomoć veštačke inteligencije

  • Profesor veštačke inteligencije i računarskih neuronauka  Zoran Jovičić .AI United College

DEO 1: PRINCIPI AGENTIC AUTOMATIZACIJE

1.1 Šta je Agentic Automatizacija?

Agentic automatizacija predstavlja naprednu formu automatizacije gde autonomni AI agenti samostalno donose odluke, planiraju akcije i izvršavaju zadatke bez konstantnog nadzora čoveka. Za razliku od tradicionalne automatizacije koja sledi unapred definisane korake, agentic sistemi mogu:

  • Samostalno razmišljati o problemima
  • Planirati sekvence akcija
  • Donositi odluke na osnovu konteksta
  • Učiti iz prethodnih iskustava
  • Prilagođavati se novim situacijama

1.2 Ključne Karakteristike

Autonomija: Agenti rade sa minimalnom intervencijom korisnika, samostalno određujući najbolji put do cilja.

Proaktivnost: Ne čekaju eksplicitne komande već anticipiraju potrebe i preduzimaju akcije.

Reaktivnost: Reaguju na promene u okruženju u realnom vremenu.

Socijalna sposobnost: Komuniciraju sa drugim agentima i sistemima kroz API-je i protokole.

Ciljno orijentisani: Fokusirani su na postizanje definisanih ciljeva, ne samo na izvršavanje zadataka.

1.3 Arhitektura Agentic Sistema

┌─────────────────────────────────────┐ │ PERCEPCIJA (Perception) │ │ - Prikupljanje informacija │ │ - Analiza konteksta │ └──────────────┬──────────────────────┘ │ ▼ ┌─────────────────────────────────────┐ │ RAZMIŠLJANJE (Reasoning) │ │ - LLM procesiranje │ │ - Planiranje koraka │ │ - Donošenje odluka │ └──────────────┬──────────────────────┘ │ ▼ ┌─────────────────────────────────────┐ │ AKCIJA (Action) │ │ - Izvršavanje zadataka │ │ - API pozivi │ │ - Manipulacija alatima │ └──────────────┬──────────────────────┘ │ ▼ ┌─────────────────────────────────────┐ │ MEMORIJA (Memory) │ │ - Kratkoročna (kontekst) │ │ - Dugoročna (vektorska baza) │ └─────────────────────────────────────┘

1.4 Osnovni Principi Dizajniranja

Princip 1: Jasna Definicija Cilja
Agent mora imati nedvosmislen cilj. Nejasni ciljevi vode ka neočekivanom ponašanju.

Princip 2: Kontrolisana Autonomija
Balans između samostalnosti i sigurnosnih ograničenja. Implementirati “human-in-the-loop” za kritične odluke.

Princip 3: Observabilnost
Agent mora biti transparentan – svaka akcija mora biti pratljiva i razumljiva.

Princip 4: Otpornost na Greške
Sistemi moraju elegantno rukurti greškama i imati mehanizme oporavka.

Princip 5: Iterativno Poboljšanje
Agenti moraju učiti iz interakcija i poboljšavati se tokom vremena.

1.5 Razlika: Tradicionalna vs. Agentic Automatizacija

Aspekt Tradicionalna Agentic Logika If-then pravila AI rasuđivanje Fleksibilnost Rigidna Adaptivna Kompleksnost Linearna Multi-step planiranje Učenje Statička Dinamičko učenje Skalabilnost Ograničena Visoka

1.6 Slučajevi Primene

  • Korisnička podrška: AI agenti koji vode kompleksne konverzacije
  • Istraživanje i analiza: Autonomno prikupljanje i sinteza informacija
  • Upravljanje projektima: Automatsko dodeljivanje zadataka i praćenje
  • Prodaja i marketing: Personalizovana komunikacija sa potencijalnim klijentima
  • IT operacije: Automatsko otkrivanje i rešavanje problema

DEO 2: NO-CODE PLATFORME ZA AGENTIC AUTOMATIZACIJU

2.1 Make (Integromat)

Pregled:
Make je vizuelna platforma za automatizaciju sa naprednim mogućnostima za integraciju AI servisa.

Ključne Karakteristike:

  • Vizuelni scenario builder sa drag-and-drop interfejsom
  • 1500+ integracija (Google, Slack, OpenAI, Anthropic, itd.)
  • HTTP moduli za custom API pozive
  • Data store za perzistentne podatke
  • Error handling i routing logic

Agentic Mogućnosti:

  • Integracija sa OpenAI GPT-4, Claude, Gemini
  • Lanac AI poziva za kompleksno rasuđivanje
  • Webhook trigeri za event-driven arhitekturu
  • Iterator moduli za procesiranje nizova podataka

Pricing:

  • Free: 1,000 operacija/mesec
  • Core: od $9/mesec
  • Pro: od $16/mesec
  • Teams/Enterprise: Custom

Best For: Srednje kompleksne automatizacije sa potrebom za brojnim integracijama

2.2 Zapier

Pregled:
Najpoznatija no-code platforma za automatizaciju sa preko 6,000 aplikacija.

Ključne Karakteristike:

  • Intuitivni Zap builder
  • AI by Zapier – ugrađene AI funkcionalnosti
  • Multi-step Zaps
  • Filters, Paths, i Formatter alati
  • Built-in AI chatbot (Zapier Chatbots)

Agentic Mogućnosti:

  • OpenAI integracija za generisanje teksta
  • AI Email parser
  • Condition-based routing
  • Custom Webhooks

Pricing:

  • Free: 100 zadataka/mesec
  • Starter: $19.99/mesec
  • Professional: $49/mesec
  • Team/Enterprise: Custom

Best For: Brze automatizacije i poslovne aplikacije sa poznatim servisima

2.3 n8n

Pregled:
Open-source workflow automatizacija sa snažnom AI podrškom.

Ključne Karakteristike:

  • Self-hosted ili cloud
  • Vizuelni workflow editor
  • JavaScript izvršavanje unutar node-ova
  • 400+ integracija
  • Kompleksna logika i error handling

Agentic Mogućnosti:

  • AI Agent node sa podrškom za LangChain
  • Tool calling capabilities
  • Vector store integracije (Pinecone, Weaviate)
  • Memory management za konverzacione agente
  • Chat model integracije (OpenAI, Anthropic, Cohere)

Pricing:

  • Self-hosted: Besplatno (open-source)
  • Cloud Starter: $20/mesec
  • Cloud Pro: Custom

Best For: Developeri i timovi koji žele potpunu kontrolu i prilagodljivost

2.4 Relevance AI

Pregled:
Specijalizovana platforma za kreiranje i deploy AI agenata.

Ključne Karakteristike:

  • No-code AI agent builder
  • Built-in LLM integracije
  • Tool creation i management
  • Chain-of-thought reasoning
  • Multi-agent orchestration

Agentic Mogućnosti:

  • Autonomni agenti sa memory
  • Custom tool development
  • Agent collaboration
  • Real-time monitoring
  • Knowledge base integration

Pricing:

  • Free tier dostupan
  • Starter: od $99/mesec
  • Pro/Enterprise: Custom

Best For: Dedicirane AI agent aplikacije i kompleksni multi-agent sistemi

2.5 Voiceflow

Pregled:
Platforma za dizajniranje konverzacionih AI agenata i chatbot-ova.

Ključne Karakteristike:

  • Vizuelni conversation designer
  • NLU (Natural Language Understanding)
  • API integracije
  • Multi-channel deployment
  • Analytics dashboard

Agentic Mogućnosti:

  • LLM-powered responses
  • Context awareness
  • Dynamic conversation flow
  • Knowledge base RAG
  • Function calling

Pricing:

  • Sandbox: Besplatno
  • Pro: $40/mesec
  • Teams/Enterprise: Custom

Best For: Konverzacioni agenti, customer support bot-ovi

2.6 Activepieces

Pregled:
Open-source alternativa Zapier-u sa fokusom na AI automatizaciju.

Ključne Karakteristike:

  • Open-source i self-hosted
  • Moderna UI/UX
  • Piece system (komponente)
  • Branch logic i loops
  • Error handling

Agentic Mogućnosti:

  • OpenAI i Anthropic integracije
  • Custom code pieces u TypeScript-u
  • Webhook automation
  • Scheduled triggers

Pricing:

  • Self-hosted: Besplatno
  • Cloud: Od $250/mesec

Best For: Timovi koji žele open-source rešenje sa modernim interfejsom

2.7 Mindstudio

Pregled:
No-code platforma za kreiranje custom AI aplikacija i agenata.

Ključne Karakteristike:

  • Visual AI app builder
  • Pre-built templates
  • Custom UI creation
  • Multi-LLM support
  • Deployment u nekoliko klikova

Agentic Mogućnosti:

  • Autonomous workers
  • Tool integration
  • Memory i context management
  • Chain-of-thought workflows

Pricing:

  • Free tier
  • Pro: $20+/mesec
  • Enterprise: Custom

Best For: Brzo prototipiranje AI agenata i aplikacija

2.8 Komparacija Platformi

Platforma Složenost AI Moć Cena Best Use Case Make Srednja Visoka $$ Složene integracije Zapier Niska Srednja $$$ Brze automatizacije n8n Visoka Veoma visoka $ Custom AI agenti Relevance AI Srednja Veoma visoka $$$ AI-first projekti Voiceflow Niska-Srednja Visoka $$ Chatboti Activepieces Srednja Srednja-Visoka $ Open-source potrebe Mindstudio Niska Visoka $$ Rapid prototyping

DEO 3: PRIMERI AUTOMATIZOVANJA – JEDNOSTAVNI

Primer 1: Automatski Email Odgovori sa Kontekstom

Platforma: Make + OpenAI

Cilj: Agent koji automatski odgovara na email-ove prema tonu i kontekstu

Koraci:

  1. Trigger: Gmail – Watch emails (nova poruka)
  2. Filter: Provera da li email zahteva odgovor
  3. OpenAI modul: Analiza email-a

Prompt: "Analiziraj sledeći email i klasifikuj ga: - tip: pitanje/zahtev/pritužba - hitnost: niska/srednja/visoka - ton: formalan/casual/ljutit Email: {{1.text}}"

  1. Router: Na osnovu klasifikacije
  2. OpenAI modul: Generisanje odgovora

Prompt: "Generiši profesionalan odgovor na email: Originalni email: {{1.text}} Tip: {{3.tip}} Ton za odgovor: {{3.ton}} Odgovor treba biti: - Ljubazan i profesionalan - Maksimalno 150 reči - Rešava pitanje ili nudi sledeće korake"

  1. Gmail modul: Slanje odgovora
  2. Google Sheets: Logovanje interakcije

Vreme implementacije: 30 minuta
ROI: 5-10 sati nedeljno za support tim

Primer 2: LinkedIn Lead Generator Agent

Platforma: Zapier + Claude (Anthropic)

Cilj: Automatsko identifikovanje i kontaktiranje relevantnih lead-ova

Koraci:

  1. Trigger: LinkedIn – New connection
  2. LinkedIn Scraper: Izvlačenje profila informacija
  3. Claude AI:

Prompt: "Na osnovu LinkedIn profila, proceni: - Da li je ova osoba potencijalni klijent? - Scoring (1-10): verovatnoća konverzije - Personalizovani icebreaker Profil: {{2.profile_data}} Naša industrija: [vaša_industrija]"

  1. Filter: Samo lead-ovi sa score > 7
  2. Wait: 24 sata (da ne deluje kao spam)
  3. Claude AI: Generisanje personalizovane poruke
  4. LinkedIn: Slanje poruke
  5. CRM (HubSpot/Salesforce): Kreiranje kontakta

Vreme implementacije: 1 sat
ROI: 20+ kvalifikovanih lead-ova nedeljno

Primer 3: Social Media Content Scheduler

Platforma: Make + GPT-4

Cilj: Agent koji kreira i objavljuje content prilagođen svakoj platformi

Koraci:

  1. Trigger: Webhook ili Schedule (npr. svaki ponedeljak)
  2. RSS/News API: Prikupljanje relevantnih vesti iz industrije
  3. GPT-4: Analiza i selekcija

Prompt: "Od sledećih članaka, izaberi 3 najrelevantnije za našu publiku [opis_publike]: {{2.articles}}"

  1. Iterator: Za svaki izabrani članak
  2. GPT-4: Kreiranje multi-platform content

Prompt: "Kreiraj social media postove: - Twitter: 280 karaktera + hashtags - LinkedIn: profesionalni post 200 reči - Instagram: caption + emoji Članak: {{4.article}} Brand voice: [opis_tone_of_voice]"

  1. DALL-E: Generisanje slike (opciono)
  2. Router: Po platformi
  • Twitter API: Post na Twitter
  • LinkedIn API: Post na LinkedIn
  • Instagram API: Post na Instagram
  1. Airtable: Skladištenje objavljenog content-a

Vreme implementacije: 2 sata
ROI: 10+ sati nedeljno za content tim

DEO 4: PRIMERI AUTOMATIZOVANJA – NAPREDNI

Primer 4: Multi-Agent Customer Support System

Platforma: n8n + LangChain + Multiple LLMs

Arhitektura: Specializovani agenti koji sarađuju

Agenti:

1. Triage Agent (Claude Sonnet)

  • Prima sve dolazne upite
  • Klasifikuje po tipu (tehnički/prodaja/naplata/complaint)
  • Određuje hitnost
  • Rutira ka odgovarajućem agentu

2. Technical Agent (GPT-4)

  • Pristup knowledge base-i
  • RAG (Retrieval Augmented Generation) za tehničku dokumentaciju
  • Može izvršavati dijagnostiku preko API-ja
  • Eskalira kompleksne probleme ljudima

3. Sales Agent (Claude Opus)

  • Pristup CRM-u
  • Personalizacija bazirano na istoriji kupovine
  • Upsell/cross-sell preporuke
  • Kreira draft ponude

4. Orchestrator Agent

  • Koordinira sve agente
  • Upravlja conversation flow-om
  • Obezbjeđuje konzistentnost odgovora
  • Human handoff kada je potrebno

Workflow:Korisnik → Triage Agent ↓ [Klasifikacija] ↓ ┌────┴────┬────────┬─────────┐ ↓ ↓ ↓ ↓ Technical Sales Billing Complaint Agent Agent Agent Agent ↓ ↓ ↓ ↓ └─────────┴────────┴─────────┘ ↓ Orchestrator Agent ↓ Finalni Odgovor

n8n Implementation:

  1. Webhook Node: Prima poruke
  2. AI Agent Node (Triage): Klasifikacija
  3. Switch Node: Routing logika
  4. Parallel Branches: Svaki agent u svom branch-u
  5. Function Node: JavaScript za orchestration
  6. Vector Store Queries: Za knowledge base
  7. API Calls: Integracija sa CRM, billing, etc.
  8. Human-in-Loop Node: Za eskalaciju
  9. Response Formatting: Konačan odgovor

Tehnologije:

  • LangChain za agent framework
  • Pinecone za vector store
  • PostgreSQL za conversation history
  • Redis za caching
  • Prometheus za monitoring

Metrike:

  • First Response Time: < 30 sekundi
  • Resolution Rate: 75% autonomno
  • Customer Satisfaction: 4.5/5
  • Cost per interaction: $0.15

Vreme implementacije: 40+ sati
ROI: 60% redukcija support troškova

Primer 5: Autonomous Market Research Agent

Platforma: n8n + GPT-4 + Custom Tools

Cilj: Agent koji sprovodi kompletno market research i generiše izvještaje

Komponente:

1. Research Planner Agent// Pravi detaljan plan istraživanja const planPrompt = ` Kreiraj detaljni plan market research-a za: ${industry} Uključi: - Ključna pitanja za istraživanje - Izvore podataka - Metodologiju analize - Timeline `;

2. Data Collection Agent

  • Web scraping (Puppeteer integration)
  • API pozivi (Crunchbase, LinkedIn, itd.)
  • RSS feed monitoring
  • Database queries
  • PDF extraction

3. Analysis Agent# Koristi advanced prompting tehnike analysis_prompt = f""" Analiziraj prikupljene podatke koristeći sledeće framework: 1. SWOT analiza 2. Porter's Five Forces 3. Trend identification 4. Competitive landscape Podaci: {collected_data} Format odgovora kao strukturirani JSON. """

4. Report Generator Agent

  • Strukturiranje nalaza
  • Vizualizacija podataka (Chart.js, Matplotlib)
  • Executive summary generation
  • Kreiranje PDF izvještaja
  • PowerPoint generacija

5. Quality Checker Agent

  • Verifikacija podataka
  • Fact-checking preko multiple sources
  • Consistency check
  • Citation validation

n8n Workflow:Schedule Trigger (monthly) ↓ Research Planner Agent ↓ Data Collection Loop ├→ Web Scraper ├→ API Calls ├→ Database Query └→ Document Parser ↓ Data Validation ↓ Analysis Agent (iterative) ├→ Quantitative Analysis ├→ Qualitative Analysis └→ Synthesis ↓ Quality Check ↓ Report Generator ├→ Text generation ├→ Chart creation ├→ PDF compilation └→ PowerPoint creation ↓ Distribution ├→ Email ├→ Slack notification └→ Cloud storage

Advanced Features:

  • Multi-source synthesis: Kombinuje podatke iz 20+ izvora
  • Temporal analysis: Prati promene tokom vremena
  • Predictive insights: ML modeli za forecasting
  • Automated fact-checking: Verifikacija sa više nezavisnih izvora
  • Custom visualizations: Automatski generiše grafikone

Tools Used:

  • SerpAPI za Google searches
  • Diffbot za web extraction
  • NewsAPI za news monitoring
  • Crunchbase API za company data
  • GPT-4 Vision za analizu grafikona i slika
  • Langchain SQL Agent za database queries

Vreme implementacije: 80+ sati
ROI: Mesečni izvještaji koji bi inače kostali $5,000+ od konzultanata

Primer 6: Intelligent Project Management Agent

Platforma: Make + Anthropic Claude + Project Management APIs

Cilj: Autonomno upravljanje projektima, resursima i rizicima

Agenti:

1. Project Analyzer Agent

  • Dnevna analiza project board-a (Asana/Jira/Monday)
  • Identifikacija bottleneck-ova
  • Resource utilization analysis
  • Risk assessment

2. Task Allocator Agent// Inteligentno dodjeljivanje taskova const allocationPrompt = ` Analiziraj taskove i članove tima: Taskovi: ${pendingTasks} Tim: ${teamMembers} Za svaki task odredi: - Najbolja osoba (skill match + workload) - Prioritet - Estimated time - Dependencies Razmatraj: - Current workload - Skills i expertise - Past performance - Deadlines `;

3. Standup Generator Agent

  • Automatski generiše daily standup notes
  • Prikuplja updates od svih članova
  • Identifikuje blockers
  • Predlaže akcione korake

4. Risk Management Agent

  • Predikcija kašnjenja
  • Budget tracking
  • Resource conflicts
  • Automated escalation

5. Reporting Agent

  • Weekly progress reports
  • Stakeholder updates
  • KPI tracking
  • Burndown chart analysis

Make Scenario:Modules Flow: 1. Schedule (every morning 9 AM) 2. Asana API: Get all tasks 3. Google Calendar API: Get team availability 4. Claude: Analyze workload distribution 5. Router: Based on analysis ├→ Over-allocated: Send alerts ├→ Under-allocated: Suggest new tasks └→ Balanced: Continue monitoring 6. Claude: Generate optimal task assignments 7. Iterator: For each recommended change 8. Asana API: Update task assignments 9. Slack Webhook: Notify team members 10. Claude: Generate standup summary 11. Slack: Post to #standup channel 12. Google Sheets: Log metrics 13. If (deadline_risk > 70%): └→ Email: Escalation to PM 14. Weekly aggregator (runs Fridays) 15. Claude: Generate executive report 16. Email: Send to stakeholders

Advanced Logic:// Prioritization algorithm function calculatePriority(task) { const urgencyScore = calculateDeadlineProximity(task.due_date); const impactScore = task.business_value || 5; const dependencyScore = countDependentTasks(task.id); const effortScore = 10 - (task.estimated_hours / 8); return (urgencyScore * 0.3) + (impactScore * 0.3) + (dependencyScore * 0.2) + (effortScore * 0.2); } // Risk detection function detectRisks(project) { const risks = []; if (project.burnRate > project.budget * 0.8) { risks.push({type: 'budget', severity: 'high'}); } if (project.completion < project.expectedCompletion * 0.9) { risks.push({type: 'timeline', severity: 'medium'}); } return risks; }

Integrations:

  • Asana/Jira/Monday.com
  • Google Calendar/Outlook
  • Slack/Teams
  • Harvest/Toggl (time tracking)
  • GitHub (code metrics)
  • Confluence (documentation)

Metrics:

  • Task assignment time: Od 30 min → 5 min
  • Project delays: Redukcija 40%
  • Resource utilization: Poboljšanje 25%
  • PM time saved: 15 sati/nedelja

Vreme implementacije: 60+ sati
ROI: $10,000+ godišnje po PM-u

DEO 5: BEST PRACTICES I OPTIMIZACIJA

5.1 Prompt Engineering za Agente

Chain-of-Thought Prompting:Analiziraj problem korak-po-korak: Problem: {{user_input}} Razmišljanje: 1. Prvo, identifikuj ključne elemente problema 2. Zatim, razmotri moguće pristupe 3. Evaluiraj svaki pristup 4. Odaberi najbolji pristup 5. Implementiraj rešenje Finalni odgovor: [tvoj odgovor]

Few-Shot Learning:Evo primera kako treba odgovoriti: Primer 1: Input: "Kako da resetujem password?" Output: { "category": "technical_support", "priority": "medium", "response": "Evo koraka za reset..." } Primer 2: Input: "Želim da otkažem pretplatu" Output: { "category": "billing", "priority": "high", "response": "Razumem da želite da..." } Sada, procesuiraj: Input: {{user_message}} Output:

ReAct (Reasoning + Acting):Izvršavaš zadatak korak-po-korak: Zadatak: {{task}} Za svaki korak koristi format: Thought: [šta razmišljaš] Action: [koju akciju preduzmaš] Observation: [šta si saznao] Nastavi dok ne stigneš do: Final Answer: [konačan odgovor]

5.2 Upravljanje Kontekstom i Memorijom

Sliding Window Context:// Čuvaj samo relevantni kontekst function manageContext(messages, maxTokens = 8000) { let context = []; let totalTokens = 0; // Uvek zadrži system prompt i prva 2 messages const systemMessages = messages.slice(0, 3); // Uzmi najnovije poruke koje stanu u limit for (let i = messages.length - 1; i >= 3; i--) { const msg = messages[i]; const msgTokens = estimateTokens(msg); if (totalTokens + msgTokens < maxTokens) { context.unshift(msg); totalTokens += msgTokens; } else { break; } } return [...systemMessages, ...context]; }

Vector Memory Implementation:// Skladištenje dugoročne memorije async function storeMemory(interaction) { const embedding = await openai.embeddings.create({ model: "text-embedding-ada-002", input: interaction.content }); await pinecone.upsert({ vectors: [{ id: interaction.id, values: embedding.data[0].embedding, metadata: { timestamp: Date.now(), user_id: interaction.user_id, category: interaction.category } }] }); } // Pretraga relevantnih memorija async function retrieveMemories(query, topK = 5) { const queryEmbedding = await openai.embeddings.create({ model: "text-embedding-ada-002", input: query }); const results = await pinecone.query({ vector: queryEmbedding.data[0].embedding, topK: topK, includeMetadata: true }); return results.matches; }

5.3 Error Handling i Fail-safes

Retry Logic sa Exponential Backoff:async function apiCallWithRetry(apiFunction, maxRetries = 3) { for (let i = 0; i < maxRetries; i++) { try { return await apiFunction(); } catch (error) { if (i === maxRetries - 1) throw error; const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s console.log(`Retry ${i + 1} after ${delay}ms`); await sleep(delay); } } }

Fallback Mehanizmi:// Multi-model fallback async function getAIResponse(prompt) { try { // Pokušaj sa primarnim modelom return await claude.complete(prompt); } catch (claudeError) { console.log("Claude failed, trying GPT-4"); try { return await openai.complete(prompt); } catch (gptError) { console.log("GPT-4 failed, using template response"); return generateTemplateResponse(prompt); } } }

Circuit Breaker Pattern:class CircuitBreaker { constructor(threshold = 5, timeout = 60000) { this.failureCount = 0; this.threshold = threshold; this.timeout = timeout; this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN } async execute(operation) { if (this.state === 'OPEN') { if (Date.now() - this.lastFailureTime > this.timeout) { this.state = 'HALF_OPEN'; } else { throw new Error('Circuit breaker is OPEN'); } } try { const result = await operation(); this.onSuccess(); return result; } catch (error) { this.onFailure(); throw error; } } onSuccess() { this.failureCount = 0; this.state = 'CLOSED'; } onFailure() { this.failureCount++; this.lastFailureTime = Date.now(); if (this.failureCount >= this.threshold) { this.state = 'OPEN'; } } }

5.4 Monitoring i Optimizacija

Logging i Observability:// Structured logging function logAgentAction(action) { const logEntry = { timestamp: new Date().toISOString(), agent_id: action.agent_id, action_type: action.type, input_tokens: action.input_tokens, output_tokens: action.output_tokens, latency_ms: action.latency, cost_usd: calculateCost(action), success: action.success, error: action.error || null }; // Send to logging service console.log(JSON.stringify(logEntry)); // Also send to monitoring dashboard sendToMonitoring(logEntry); }

Performance Metrics:// Track key metrics const metrics = { totalRequests: 0, successfulRequests: 0, averageLatency: 0, totalCost: 0, track(request) { this.totalRequests++; if (request.success) this.successfulRequests++; // Update rolling average this.averageLatency = ( (this.averageLatency * (this.totalRequests - 1)) + request.latency ) / this.totalRequests; this.totalCost += request.cost; }, getSuccessRate() { return (this.successfulRequests / this.totalRequests) * 100; } };

Cost Optimization:// Token usage optimization function optimizePrompt(prompt) { // Remove unnecessary whitespace let optimized = prompt.trim().replace(/\s+/g, ' '); // Use shorter alternatives optimized = optimized .replace(/please/gi, '') .replace(/could you/gi, '') .replace(/I would like you to/gi, ''); return optimized; } // Caching for repeated queries const cache = new Map(); async function getCachedResponse(prompt, ttl = 3600000) { const hash = hashPrompt(prompt); const cached = cache.get(hash); if (cached && Date.now() - cached.timestamp < ttl) { return cached.response; } const response = await getAIResponse(prompt); cache.set(hash, { response, timestamp: Date.now() }); return response; }

5.5 Sigurnost i Compliance

Input Sanitization:function sanitizeInput(userInput) { // Remove potential injection attacks const sanitized = userInput .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '') .replace(/javascript:/gi, '') .replace(/on\w+\s*=/gi, ''); // Limit length return sanitized.slice(0, 5000); }

PII Detection i Redaction:async function detectAndRedactPII(text) { // Use AI to detect PII const analysis = await claude.complete(` Identify any PII in this text: ${text} Return JSON with: - hasPII: boolean - types: array of PII types found - redactedText: text with [REDACTED] replacing PII `); const result = JSON.parse(analysis); if (result.hasPII) { logPIIDetection(result.types); } return result.redactedText; }

Access Control:// Role-based access for agents const agentPermissions = { 'customer-support': ['read:tickets', 'write:responses', 'read:knowledge'], 'data-analyst': ['read:data', 'execute:queries', 'write:reports'], 'admin-agent': ['*'] }; function checkPermission(agent, action) { const permissions = agentPermissions[agent.role]; return permissions.includes(action) || permissions.includes('*'); }

5.6 Skaliranje

Load Balancing:// Distribute requests across multiple agents class AgentPool { constructor(agentCount = 5) { this.agents = Array(agentCount).fill(0).map((_, i) => ({ id: i, busy: false, requestCount: 0 })); } async execute(task) { const agent = this.getAvailableAgent(); agent.busy = true; agent.requestCount++; try { const result = await this.processTask(agent, task); return result; } finally { agent.busy = false; } } getAvailableAgent() { // Round-robin selection const available = this.agents.filter(a => !a.busy); if (available.length === 0) { // Wait for an agent to become available return this.waitForAgent(); } // Return agent with least requests return available.sort((a, b) => a.requestCount - b.requestCount )[0]; } }

Rate Limiting:class RateLimiter { constructor(maxRequests, windowMs) { this.maxRequests = maxRequests; this.windowMs = windowMs; this.requests = new Map(); } async checkLimit(userId) { const now = Date.now(); const userRequests = this.requests.get(userId) || []; // Remove old requests outside window const validRequests = userRequests.filter( timestamp => now - timestamp < this.windowMs ); if (validRequests.length >= this.maxRequests) { throw new Error('Rate limit exceeded'); } validRequests.push(now); this.requests.set(userId, validRequests); } }

5.7 Testing i QA

Unit Testing Agent Logic:// Jest example describe('Triage Agent', () => { test('correctly classifies technical question', async () => { const input = "How do I reset my password?"; const result = await triageAgent.classify(input); expect(result.category).toBe('technical_support'); expect(result.priority).toBeGreaterThan(5); }); test('handles edge cases', async () => { const inputs = ['', null, 'a'.repeat(10000)]; for (const input of inputs) { const result = await triageAgent.classify(input); expect(result).toHaveProperty('category'); } }); });

Integration Testing:// Test entire workflow describe('Customer Support Workflow', () => { test('end-to-end happy path', async () => { const mockRequest = { user: 'test@example.com', message: 'I need help with billing' }; const response = await customerSupportWorkflow.execute(mockRequest); expect(response.resolved).toBe(true); expect(response.sentiment).toBe('positive'); expect(response.responseTime).toBeLessThan(5000); }); });

A/B Testing:// Compare different prompts or models class ABTest { constructor(variants) { this.variants = variants; // [{id, prompt, weight}] this.results = new Map(); } selectVariant() { // Weighted random selection const totalWeight = this.variants.reduce((sum, v) => sum + v.weight, 0); let random = Math.random() * totalWeight; for (const variant of this.variants) { random -= variant.weight; if (random <= 0) return variant; } } recordResult(variantId, metrics) { if (!this.results.has(variantId)) { this.results.set(variantId, []); } this.results.get(variantId).push(metrics); } getWinner() { const stats = new Map(); for (const [variantId, results] of this.results) { const avgSuccess = results.reduce((sum, r) => sum + (r.success ? 1 : 0), 0 ) / results.length; stats.set(variantId, avgSuccess); } return [...stats.entries()].sort((a, b) => b[1] - a[1])[0]; } }

ZAKLJUČAK

Agentic automatizacija predstavlja paradigm shift u načinu na koji automatizujemo poslovne procese. Ključne lekcije:

1. Počnite jednostavno: Ne pokušavajte odmah graditi kompleksne multi-agent sisteme. Počnite sa jednostavnim workflow-ima i postupno dodajte kompleksnost.

2. Fokus na ROI: Uvek merite uticaj. Najbolje automatizacije su one koje štede vreme i novac na merljiv način.

3. Human-in-the-loop: Za kritične odluke, uvek imajte čoveka u procesu. Agenti su sjajni asistenti, ali ne mogu sve.

4. Kontinuirano učenje: Sistemi moraju evoluirati. Koristite feedback loops i konstantno optimizujte.

5. Sigurnost je prioritet: Nikada ne žrtvujte sigurnost radi brzine implementacije.

Sledeći koraci:

  • Identifikujte repetitivne procese u vašoj organizaciji
  • Odaberite odgovarajuću no-code platformu
  • Implementirajte pilot projekat
  • Merite rezultate
  • Skalirајte uspešne automatizacije

Resursi za dalje učenje:

Autori su dostupni za konsultacije.

Verzija: 1.0 | Datum: Septembar 2025

Published by

Zoran Jovicic

Leave a comment