SkaiLab

Practical course · Online with instructors

Implementing AI in business

Learn AI tools and create your own agents and applications. Progress from your first tasks to an implementation plan for your company.

From RUB 29,900 for the complete course

From AI tools
to your own solutions

15 classes
from models to implementation
30 hours
online with practitioners
Your own projects
agents, automations and applications

Rating 5.0on review platforms

Format
Online
with experts
Skills
We write code
with AI
Scope
15 classes
30 hours
Outcome
Your own solutions
and an implementation plan
Enrol in the course

Clients and partners

AlmalyAVKFinn FlareGrowfoodHSE UniversityInfratechISARISSK2 CloudCROCMoscow Pedagogical State UniversityOrion SoftPTC TherapeuticsSberUniversitySkolkovoSvoy BankTECHNONICOLUral Federal UniversityVED YugYADROYandex

What you will learn

From the first prompt
to a working solution

Each stage ends with practical work. We progressively connect models, data, tools and applications into working processes.

AI agents for work tasks

Configure instructions, Skills and tools. Build an assistant for preparing proposals and working with clients.

Automation and a knowledge base

Connect enquiries, documents and your CRM in n8n. Add search across company knowledge and check answer quality.

Applications and launch

Go from competitor research to an application: content, interface, data, version control and publication.

Implementation plan and economics

Choose a business initiative, define its architecture, estimate resources and costs, and set pilot criteria.

Who it is for

For those who want to
apply AI at work

Bring a task from your company, department or independent practice. We explore tools through specific processes.

For executives and business owners

Understand AI capabilities, choose implementation opportunities and assess costs before launching a project.

For marketers and sales leaders

Set up research, content creation, enquiry processing and assistance for sales teams working with clients.

For product and project managers

Build prototypes with AI, test user scenarios and take applications through to deployment.

For HR, business development and consultants

Automate work with documents, knowledge and recurring tasks. Build your own practical workflows.

How the training works

First, try it.
Then connect it into a system.

15 two-hour classes. Recordings, practical materials and a shared chat are available in both plans.

From an idea
to your own solution

01

Live sessions + recordings

Online sessions with instructors: we explain principles, demonstrate tools and move into practice. Recordings of all 15 sessions are available in both plans.

02

Practice on real work tasks

Preparing commercial proposals, processing enquiries, searching documents, and creating content and applications. Work through the entire path from defining the task to verifying the result.

03

Feedback and support

A shared participant chat for discussing the course. The Supported plan includes priority expert responses, 3 group brainstorming sessions and final project reviews.

Classes 1–6

Models, agents
and automation

Learn to define tasks, connect tools, work with corporate knowledge and check results.

Classes 7–12

Applications
and persistent assistants

Create content and applications, explore service deployment and configure agents with schedules and memory.

Classes 13–15

Implementation
and business outcomes

Choose an initiative, describe integrations, assess infrastructure and economics, and draw up a pilot plan.

The SkaiLab approach

Learn through the tasks
your business actually faces

We preserve the programme's depth and connect technology to a specific process. The aim is to understand how a solution works and what is needed to apply it.

01

We work with your processes

Lead generation, sales stages, reporting, analytics and document work. Learn to identify recurring tasks, describe inputs and choose a suitable automation method.

02

We focus on business outcomes

Define exactly what should change: completion time, cost, quality or error count. Compare the result with the original process and assess implementation economics.

03

We provide workflows and templates

Agent instructions, Skills, practical assignments, code and integration examples. The materials help you reproduce a solution and adapt it to your own task.

04

We connect learning with implementation

Individual tools come together as a system: models, knowledge, work services and applications. The Supported plan includes private group sessions to discuss your use cases.

Course programme

5 modules.
15 practical classes.

Practical AI use and implementation in your company: from working with models to architecture, economics and a pilot.

30 clock hours. Additional independent work is not included in this total.

01

Module 1 · 3 classes · 6 hours

Working with AI and agent workflows

Sessions 1–3 · 6 hours. How to obtain verifiable results and delegate a repeatable work task to an agent.

01

The AI industry

models, tools and practical foundations

2 hours
Theory
  • The components of the AI industry: models, applications, tools and agent systems — their purposes and relationships.
  • How LLMs work: tokens, context windows, response generation, hallucinations and other model limitations.
  • Reasoning models and standard responses: choosing a mode based on task complexity, waiting time and how the result can be verified.
  • Task definition fundamentals: instructions, context, input data, requirements and output format.
  • System and user instructions: purpose, priority and separating permanent rules from a specific task; Markdown files for storing and reusing system prompts and instructions
  • Decomposing multi-step tasks: action sequences, intermediate outputs and transferring context between stages.
  • Projects and persistent context: organising instructions, source materials and outputs for recurring tasks.
  • Working with corporate data: permitted materials and services, checking files before upload, anonymisation and separating document content from instructions.
  • NotebookLM: working with a defined source collection. Comparing tasks suited to a source-grounded environment and a regular chat.
Practice
  • Defining a task, preparing system and user instructions, and saving persistent instructions in a Markdown file.
  • Analysing multiple documents and preparing a final deliverable; refining the prompt and testing with new data.
  • Organising a project with instructions and files for repeated work.
  • Working with the same sources in NotebookLM, comparing answers, checking facts and correcting errors.
Tools

ChatGPT / Claude / NotebookLM.

02

Inside an AI agent

agent harness, instructions, skills and tools

2 hours
Theory
  • An AI agent and how it differs from a regular model conversation: planning, using context and taking actions through external tools.
  • The agent loop: planning → action → result verification → choosing the next step.
  • Agent harness: instructions, tools, context and state management, permissions, checks and an activity log. The model's role within this system.
  • Harness and runtime: agent orchestration and execution environment; their relationship and terminology differences across products.
  • The main components of an agent environment: Rules, Skills, Tools, Connectors and MCP — their purposes and interactions.
  • Persistent rules and task-specific context: which instructions to embed in the working environment and which to provide with a specific request.
  • Organising the workspace: a one-off task without prior setup versus a persistent environment with instructions, files and materials.
  • Skills as reusable capabilities: purpose, scope and how they differ from a single model prompt.
  • Skill structure: description, usage conditions, instructions, inputs, reference materials, constraints and outcome criteria.
  • The SKILL.md file and supporting materials: organising instructions, examples, reference files and code.
  • Selecting and invoking a Skill: explicit invocation and automatic selection, the role of names and descriptions, missed skills and incorrect triggers.
  • Loading materials as needed: a short description for skill selection, detailed instructions and files for execution; material availability and context size.
  • Ready-made Skills, catalogues and repositories: discovery, applicability assessment and adaptation; checking the source, instructions, dependencies, associated code and environment compatibility.
  • Tools and Connectors: agent access to data and actions in external systems.
  • MCP: connecting external tools and sources to an agent environment.
  • Agent autonomy boundaries: permitted actions, access restrictions, confirmations and human involvement.
Practice
  • Configuring an AI agent to prepare commercial proposals. Participants connect a data source or tool through MCP and adapt an existing Skill to the product and document requirements. They then complete the task using the connected data and skill, test the result on several examples and refine the instructions.
Tools

Claude Cowork / ChatGPT Work / Manus.

03

AI agent integrations

connecting work systems and completing multi-step tasks

2 hours
Theory
  • Organising a workspace for a role or business function: instructions, materials, context and connected systems.
  • Using Rules, Skills and Projects / Workspaces together: working rules, repeatable actions and data in a single environment.
  • Searching connected corporate sources: available capabilities, supported materials, source links and access permissions.
  • Separating responsibilities: Rules and Skills define how work is done, while Connectors, MCP and APIs provide data and actions.
  • Integration methods: ready-made and custom connectors, MCP and direct API access; choosing an approach for the task.
  • API fundamentals: service address, request, parameters and response; JSON as a structured data exchange format.
  • Tool descriptions: purpose, invocation conditions, input parameters, required fields, output format and possible errors.
  • An MCP connection: client and server; tools are callable functions, resources are available materials, and prompts are interaction templates. Feature support in the chosen environment.
  • Integration diagnostics: inspecting tools and schemas, test calls, responses and errors using MCP Inspector or platform tools. Distinguishing connection, tool selection, parameter and action execution errors.
  • Plugins as extension packages: combining Skills, connections and other components. Searching catalogues and repositories, checking contents, compatibility and required permissions.
  • Connecting internal company systems when no ready-made integration exists: a custom MCP server or connector.
  • Access management: reading and changing data, confirming actions, and validating parameters and permissions in the executing system.
  • Building a multi-step workflow: stages, dependencies, passing results, checkpoints and completion criteria.
  • Combining multiple Skills in one process: client research → meeting preparation → processing outcomes. The role of subagents in completing individual parts of a task.
  • Browser / Computer Use: taking actions through a website or application interface when no suitable API or connector is available.
  • Scheduled tasks: regular summaries, sales funnel analysis and customer monitoring; configuring frequency, sources and output format.
Practice
  • Configuring a personal AI assistant for a sales representative. Participants combine instructions and Skills, connect corporate sources and a test CRM through connectors or MCP, and set up client research and meeting preparation. They check data transfer between stages, tool behaviour and access restrictions. Prepared examples demonstrate connection diagnostics, browser interaction and recurring tasks.
Tools

ChatGPT Work / Claude Cowork / Manus

02

Module 2 · 3 classes · 6 hours

Process automation and corporate knowledge

Sessions 4–6 · 6 hours. How to turn individual actions into a repeatable process with data and checks.

04

AI workflow automation

logic, integrations and reliability

2 hours
Theory
  • An automated workflow: how it differs from working in chat and from delegating a task to a general-purpose AI agent.
  • Basic process structure: trigger → data processing → logic → action → result.
  • n8n as an automation environment: nodes, connections, credentials, workflow execution and passing data between stages.
  • Starting processes: webhooks and schedules; receiving data from external systems.
  • Data within a workflow: JSON, fields, transformations and passing values between nodes.
  • Connecting a language model: instructions, input data, context and response requirements.
  • Working with model platforms: API keys, model selection, request parameters, test calls, limits and cost tracking.
  • The AI Agent node: model, system instructions, memory and tools. The difference between a single model call and an agent that selects tools while executing a task.
  • Connecting tools to an agent: CRM, spreadsheets, databases and other systems; passing parameters and receiving results.
  • Structured model output: configuring the format and using the result in later process stages.
  • Validating data before an action: JSON Schema, types, required fields, allowed values and business rules. Handling incomplete or incorrect data.
  • Process logic: conditions, branching and routing based on classification results.
  • Loops, parallel branches and combining data with Merge; splitting a complex process into subprocesses and reusable blocks.
  • Working with HTTP APIs: authentication, headers, parameters, and response and error handling.
  • The Code node: data processing and additional logic beyond standard nodes.
  • Human-in-the-loop participation: reviewing, editing, approving or rejecting a result before the next action.
  • Failure handling: retries, alternative execution paths and dedicated error workflows — retries, fallback and error workflows.
  • Execution history and diagnostics: inspecting inputs and outputs, finding a failed step and checking process behaviour when an external service fails.
Practice
  • Configuring an AI agent to qualify incoming Telegram enquiries using a ready-made workflow. Participants connect a model and test CRM, define information collection and lead qualification rules, and configure structured output and data transfer. They add required-field validation and human confirmation, test normal and incomplete enquiries, and examine an external service error. Prepared fragments illustrate HTTP requests, loops, parallel branches, Merge, Code, subprocesses and retries.
Tools

n8n, OpenAI API Platform, Yandex AI Studio, Claude Console (Anthropic)

05

Working with corporate knowledge

sources, search and RAG

2 hours
Theory
  • A corporate knowledge base: information sources, material organisation, freshness and access permissions.
  • Ways to provide data to a model: files in context, search over connected sources, a custom RAG system and API / SQL requests.
  • Choosing an approach for the task: answer quality, source links, data freshness, access, integrations and cost. Using RAG within ready-made enterprise products.
  • RAG: retrieving relevant information and supplying it to the model to generate an answer.
  • RAG architecture: sources → document preparation → embeddings → vector database → retrieval → model context → answer.
  • Knowledge base sources: documents, instructions, FAQs, presentations, websites, correspondence, CRM and internal policies.
  • Document preparation, chunking and overlap: splitting materials into fragments, choosing chunk size and how document structure affects retrieval quality.
  • Generation settings: temperature, top_p and response length; their effect on variation and completeness.
  • Embeddings: numerical text representations and semantic similarity search.
  • Vector databases: storing fragments and their representations, and retrieving relevant materials.
  • Metadata: document and fragment attributes — product, customer, department, language, date, version, material type and access level.
  • Metadata filtering: limiting retrieval to the right product, department, current version and materials accessible to the user.
  • Retrieval approaches: keyword, vector and hybrid search; differences and combinations.
  • Reranking: an additional evaluation and ordering of retrieved fragments before passing them to the model.
  • Updating the knowledge base: uploading new materials, replacing versions, removing outdated documents and maintaining freshness.
  • Evaluating retrieval and answers: source relevance, correct citations, missing information, outdated facts and access restrictions.
Practice
  • Configuring an AI agent with a corporate knowledge base. Participants upload training documents, set chunk size and overlap, add metadata and connect retrieval to the agent. They compare built-in search with custom RAG using the same materials. For selected questions, they vary chunking, retrieval and generation parameters, then compare retrieved fragments and final answers. They check citations, answer completeness, handling of outdated and inaccessible documents, and behaviour when the necessary information is missing.
Tools

n8n, OpenAI API Platform, Yandex AI Studio, Claude Console (Anthropic), Qdrant, Pinecone, Milvus, Supabase (pgvector), Yandex Managed Service for PostgreSQL (pgvector),

06

Multi-agent systems and voice agents

interaction and quality evaluation

2 hours
Theory
  • Multi-agent systems: dividing tasks among agents with different roles, instructions, context and tools.
  • Choosing an architecture: one agent or several; task complexity, specialisation, cost and controllability.
  • Core interaction patterns: sequential execution — Prompt Chaining, Routing, Parallelization, Orchestrator / Workers, Supervisor, Handoff and Evaluator / Reviewer.
  • The difference between a predefined workflow and autonomous agent interaction; fixed and dynamic task execution order.
  • Shared and local context: distributing information among agents, passing intermediate outputs and retaining necessary data.
  • Allocating tools and access: knowledge bases, CRM and external systems for different roles.
  • Voice agent architecture: speech recognition → request processing → tools and knowledge base → spoken response generation.
  • Connecting a voice channel to an n8n process through Vapi, Yandex SpeechKit or similar services.
  • Text and voice channels working together: a shared knowledge base, business logic, CRM and recorded conversation outcomes.
  • Production requirements: reliability, fault tolerance, security, logging, monitoring and error recovery; the difference between a working prototype and a system ready for real workloads.
  • Golden Set: preparing test scenarios with expected results to evaluate models, RAG and agent logic.
  • Evaluation methods: automated format and rule checks, model-based content evaluation and specialist review.
  • Quality criteria and scales: examples of acceptable and unacceptable answers, with assessments justified by references to source materials.
  • Validating the model evaluator: comparing with human assessments and analysing disagreements, instability and systematic errors.
  • Automated testing: running a scenario set, versioning data, instructions, models and the evaluator; collecting results and tracking critical errors separately.
Practice
  • Configuring a customer conversation analysis system from a ready-made example. Participants assign agent roles, define evaluation criteria and check the analysis of recordings and transcripts. They test a prepared voice agent, verifying corporate knowledge base access and transfer of results to CRM. They examine text and voice channels working together, human confirmation and error handling. They run a small Golden Set and compare automated checks, model evaluations and expert assessments. They compare two system versions, record critical errors and identify required improvements.
Tools

n8n, Vapi, Yandex SpeechKit, OpenAI API Platform / Yandex AI Studio / Claude Console, Pinecone / Supabase.

03

Module 3 · 4 classes · 8 hours

Practical solutions and deployment

Sessions 7–10 · 8 hours. How to build a practical solution with a coding agent and make it available to users.

07

Coding agents

files and data, context management and subagents

2 hours
Theory
  • Coding agents: capabilities and differences from chat interfaces, general-purpose AI agents and application builders.
  • Using Claude Code / Codex for programming, information analysis, document processing and multi-step tasks.
  • The working folder: organising source materials, instructions, intermediate outputs and final files.
  • File operations: searching, reading, creating, editing and batch processing.
  • Persistent instructions: CLAUDE.md, AGENTS.md and Project Rules; output requirements, constraints and the order of applying general and local rules.
  • Working modes: discussion, planning and execution; choosing the agent's level of autonomy.
  • Git and GitHub: version control, repository hosting and the distinction between local and remote copies.
  • Core Git operations: creating and cloning a repository, inspecting changes, staging files, committing, history and restoring a previous file version.
  • Synchronising with GitHub: receiving and sending changes with pull and push.
  • Shared Skills and team rules: storage, distribution, versions, update owners and loading verification.
  • Context management: selecting materials for the current step, storing details in files and consulting them as needed.
  • History compaction: preserving the objective, constraints, decisions and unfinished actions; verifying information after a session change.
  • Subagents: Researcher, Analyst, Developer and Reviewer roles; defining a subtask, inputs, permitted tools and output format.
  • Combining results: checking sources, comparing conclusions, resolving contradictions and identifying open questions.
  • Choosing between one agent and subagents: effects on context, time and cost; differences from agent orchestration in n8n.
Practice
  • Setting up a workspace to research two competitors. Participants clone a training repository, organise materials, define instructions and adapt subagent roles for analysing websites, positioning, content and offers. They produce a comparative report, check sources and distinguish facts from hypotheses. They examine continuing after context compaction, commit changes in Git, push them to GitHub and restore a previous file version. This research becomes the basis for content creation in session 8.
Tools

Claude Code / OpenAI Codex, Git, GitHub

08

Multimodal workflows

content generation and external service integration

2 hours
Theory
  • Multimodal workflows: sequential work with text, images, video and audio.
  • From research to content: brief, ideas, script and material requirements.
  • Connecting external functionality: library, SDK, CLI, API, Connector and MCP; selecting an approach for the task.
  • Connecting services to Claude Code / Codex: configuring access, submitting tasks and retrieving status and results.
  • Third-party libraries: ready-made components for processing data, files and media.
  • Package managers and dependencies: npm / pip, library installation, version pinning and reproducible environments.
  • API keys, tokens and environment variables: using .env, separating settings from code and excluding secrets from the repository through .gitignore.
  • Transferring data between stages: file formats, intermediate outputs and aligning the inputs and outputs of different tools.
  • Assembling media with Remotion / FFmpeg: combining text, images, video and sound.
  • Content checks: alignment with the brief, consistency of text, visuals and voiceover, and correctness of final files.
  • Reusing the process: identifying input parameters and saving the launch procedure and configuration for connection to an application.
Practice
  • Creating marketing material from the research in session 7. Participants develop a brief and script, use prepared service connections, generate an image and voiceover, and assemble a short template-based video. They assign individual stages to existing subagents. They review the result and save the processing script and configuration in the repository. Lengthy video generation is examined using prepared materials. The resulting files and production process are used in session 9.
Tools

Claude Code / OpenAI Codex, OpenArt, Higgsfield, ElevenLabs, Remotion, FFmpeg, npm / pip, Git / GitHub

09

Building applications with AI

interface, business logic, testing and version control

2 hours
Theory
  • Application design: purpose, user scenarios, screens, data and actions.
  • Core components: frontend, backend, database, API and authentication; allocating responsibilities between them.
  • Lovable, Replit and Bolt: creating an application from a description, generating interfaces and logic, and connecting data; capabilities and limitations.
  • Working with a prototype: defining requirements, changing screens and features, and checking the user journey.
  • Moving to a coding agent: accessing source code and continuing development in Claude Code / Codex where export is supported.
  • Application structure: the location of the interface, business logic, configuration and data.
  • Agent-driven application improvements: code changes, local execution, diagnostics and bug fixes.
  • Connecting the process from session 8: passing interface parameters, starting processing, displaying status and saving results.
  • Database and authentication: storing materials, accounts and access to application features.
  • Git branches: working on a feature separately and merging changes into the main version.
  • Collaborative development in GitHub: pull requests, diff review, discussion and conflict resolution.
  • Checking changes: meeting the task, testing functionality and completing the user journey.
  • Hooks: automatic actions and checks during agent operation, error handling and access restrictions.
  • CI / GitHub Actions: running tests when the repository changes and checking before code is merged.
  • Reverting unsuccessful code changes and restoring a working application version.
Practice
  • Building an application for a marketing team: competitor cards, analytical findings and a content library. Participants create a basic interface in Lovable, Replit or Bolt, then continue with a compatible project or training starter in Claude Code / Codex. They add one feature for working with data or running the process from session 8. They make the change on a separate branch, review the diff and tests, and create a pull request. Prepared examples cover database connections, authentication, conflicts, hooks, CI and reverting changes. The working version moves to deployment in session 10.
Tools

Lovable / Replit / Bolt, Claude Code / OpenAI Codex, Supabase, Git, GitHub, GitHub Actions.

10

Application deployment

server infrastructure and model service connections

2 hours
Theory
  • Application deployment architecture: hosting the interface, server logic, database and external service connections.
  • VPS and hosting platforms: differences between your own server, Vercel and a serverless approach.
  • Server fundamentals: Linux, SSH, file structure, processes and ports.
  • Docker: packaging the application and dependencies, configuring and running containers.
  • Deploying the backend on Hostinger VPS: running a Node.js / Python application and connecting external dependencies.
  • Server-side execution of the process from session 8: generating materials and assembling video with Remotion / FFmpeg.
  • Deployment settings: moving configuration to the server environment, service addresses and separate frontend and backend variables.
  • Domain, DNS, HTTPS and reverse proxy: configuring a public address and access to the server API.
  • Publishing the frontend through Vercel: connecting a repository, choosing a branch, build settings and environment variables.
  • Connecting a Vercel frontend to a VPS backend: configuring the API address and access; checking task submission, status and results.
  • GitHub → Vercel / server: delivering a new application version and checking it after publication.
  • Deployment rollback: returning the service to its previous working version if an update fails.
  • Logs and diagnostics: locating application errors, external API errors and component interaction issues.
  • Basic support: availability monitoring, process restarts and recovery after failure.
Practice
  • Deploying the application from session 9 using a prepared configuration. Participants host the backend on Hostinger VPS, publish the frontend through Vercel and configure component interaction. They check the complete scenario: starting content creation from the interface, retrieving status and receiving the finished file. They then publish a change from GitHub, locate a training error in the logs and roll back to the previous deployment.
Tools

Claude Code / OpenAI Codex, Git / GitHub, Hostinger VPS, Vercel, Supabase, Docker.

04

Module 4 · 2 classes · 4 hours

Always-on agents and their development

Sessions 11–12 · 4 hours. How to preserve state between runs and validate changes in agent behaviour.

11

Always-on AI agents

runtime, events, schedules and action control

2 hours
Theory
  • Hermes Agent and OpenClaw: architecture, core capabilities and approaches to organising an assistant's work.
  • Platform comparison: setup, communication channels, Skills, tools, memory, automation and support.
  • Choosing a platform for the task: a personal assistant, departmental assistant, regular monitoring and workflow execution.
  • Installing and launching Hermes on a prepared server: connecting a model through an API and initial configuration.
  • The Hermes environment: config.yaml, .env, SOUL.md, and Skills, memory and log directories; file purposes and locations.
  • Configuring an assistant for a work role: tasks, persistent instructions, materials, output format and constraints.
  • Connecting Telegram: user access, receiving requests, and sending messages and files.
  • Connecting tools: file system, terminal, browser, MCP and external APIs.
  • Working with Skills in Hermes: installing an existing skill, adapting it to the task and verifying its use.
  • Sessions and basic memory: continuing a conversation, starting a new session, history, user information and facts retained between runs.
  • Recurring tasks: one-off execution, schedules, inputs, Skills usage and result delivery.
  • Running existing processes: calling the application from session 10, executing a script and delegating a task to a coding agent.
  • Permissions and confirmations: tool access, reading and modifying data, and actions involving a person.
  • Operational diagnostics: execution logs, tool calls, connection errors and reasons for stopping.
  • Operating the assistant: starting a service, restarting, preserving state, backing up settings and preventing repeated actions.
Practice
  • Building a marketing director's assistant in Hermes. Participants connect a model and Telegram, define work instructions, add a Skill and tools for retrieving information and calling the application from earlier sessions. They configure a regular competitor summary and on-demand content creation. They check task execution, action confirmation and state preservation after restart. This assistant is used in session 12.
Tools

Hermes Agent, OpenClaw, Claude Code / OpenAI Codex, MCP, Git / GitHub.

12

AI agent memory and development

graph databases, Skill updates and change validation

2 hours
Theory
  • Ways to develop an assistant: adding knowledge, updating memory, refining instructions, creating Skills and connecting tools.
  • The difference between teaching new workflows and fine-tuning a language model's weights.
  • Hermes built-in memory: MEMORY.md, USER.md and past-session search; storing, updating and using information.
  • Separating information: what belongs in memory, what should remain in documents and what should become a Skill.
  • Testing retention: saving a fact, using it in a new session and diagnosing missing or outdated information.
  • Extending memory with Hindsight: connecting a provider, choosing a memory bank and separating data for different work tasks.
  • Memory operations: retain information, recall it and reflect on accumulated knowledge.
  • Knowledge graphs: entities, facts and relationships using customers, products, campaigns, employees and agreements as examples.
  • Building a graph from messages and documents: extracting facts, identifying entities and preserving sources and event times.
  • Searching related information: combining information from multiple interactions to answer the current question.
  • Memory freshness: changes in terms, deadlines and owners; distinguishing previous and current information.
  • Record quality: duplicates, contradictions, repeated events and incorrect conclusions; correcting and deleting information.
  • Access and retention management: boundaries between shared and personal memory, sensitive information and retention periods.
  • Creating a Skill from a completed task: identifying the action sequence, inputs, rules and expected result.
  • Improving a Skill through feedback: analysing an error, refining instructions and testing on a new example.
  • Evaluating assistant improvements: comparing answers and actions before and after a change on the same task set; quality, time, cost and the need for human intervention.
  • Change management: instruction and Skill versions, accepting updates, backing up memory and restoring a previous state.
  • Continuing a long-running task: using saved memory and logs without losing decisions or repeating completed actions.
Practice
  • Developing the assistant from session 11. Participants add information about the company, products, customers and content preparation rules, then verify its retention and use in a new session. They connect a prepared Hindsight instance, load several related events and examine the resulting facts and relationships. They change customer or campaign terms and check which information the assistant uses in its answer. Based on a completed task, they create or refine a Skill, provide feedback on an error and repeat the scenario with new data. They compare the result with the initial version and check rollback capability.
Tools

Hermes Agent, Hindsight, Git / GitHub, Claude Code / OpenAI Codex.

05

Module 5 · 3 classes · 6 hours

Designing company implementation

Sessions 13–15 · 6 hours. How to choose a task, integrate a solution into the company and justify infrastructure and economics.

13

Organising AI implementation

process selection, prioritisation and responsibility

2 hours
AI Stack: from business challenge to solution
  • The AI Stack methodology: analyse company tasks → choose a solution approach → prepare data and the team → pilot → evaluate results → operate and develop.
  • The company's current state: AI tools, automations, enterprise systems, available data and employee skills.
  • Shared AI Stack components: models, knowledge, integrations, Skills, applications, controls and infrastructure. Reusing components across processes.
Task types and ways to apply AI
  • Individual employee work: information search and analysis, document preparation, spreadsheet processing, material creation and decision support.
  • Corporate knowledge: searching internal sources, answering documentation questions, and supporting employees and customers.
  • Process automation: request classification, data extraction, document preparation, routing and updating enterprise system records.
  • Agent workflows: multi-step tasks, tool selection, work across multiple systems, recurring checks and event-driven actions.
  • Specialist applications: a dedicated interface for a specific process, combining data, AI functions and user actions.
  • Choosing an approach: conventional automation, a ready-made AI service, a workflow containing a model, an agent or a custom application. Identifying cases where AI is unnecessary.
Selecting and prioritising initiatives
  • Describing a process: participants, inputs, systems, actions, decisions and outcome. Finding labour-intensive stages, repetitive operations, errors and delays.
  • Defining an initiative: which problem we solve, for whom, what changes and which metrics measure the result.
  • Sources of impact: time and cost savings, fewer errors, improved quality, increased productivity, sales or conversion.
  • Initiative readiness: process owner, available data, required integrations, baseline metrics and the ability to verify quality. Constraints and preparatory work.
  • Prioritisation: expected value, complexity, risks, cost, validation time and reuse potential. Selecting pilot initiatives and preparatory tasks.
Implementation requirements and organisation
  • Solution requirements: users, transaction volumes, peak loads, input and response sizes, acceptable waiting time and operating hours. Data categories and restrictions on external calls.
  • Allocating responsibility: implementation sponsor, process owner, initiative lead, IT, domain experts and relevant departments. Authority, work time and budget owners.
  • Employee–AI interaction: defining the task, execution, review and use of the result. Acceptance criteria, escalation of ambiguous cases to a person and response times.
  • Agent autonomy: recommendations, actions after confirmation and permitted autonomous operations. Conditions for extending permissions, stopping and returning to manual work.
  • Organising the implementation programme: stages, dependencies, decision gates and resource allocation between new initiatives, shared components and support.
  • Preparing employees: training, internal advisers, a library of validated scenarios and knowledge sharing. Responsibility for user support and business outcomes.
14

Enterprise AI architecture

integrations, model hosting and compute sizing

2 hours
Solution architecture and enterprise integrations
  • System components: interface, workflow or agent environment, models, tools, enterprise systems, retrieval and memory. Task execution sequence and data movement between components.
  • Integrations with CRM, ERP, email, file storage and databases: APIs, MCP and connectors. Permitted operations, change confirmation and error handling.
  • Sources of reliable information: current data versions and responsibility for quality and updates. APIs / SQL for structured data, RAG for documents, and memory and relationship graphs for accumulated context.
  • Separating application and model: which components run on CPUs, which need GPUs and how they interact through APIs. Connecting multiple applications and agents to a shared model service.
Model types and selection for a task
  • Language models: analysis, classification, information extraction and text generation. Reasoning capabilities for multi-step reasoning tasks; specialised models for code.
  • Multimodal models and services: image and document analysis, speech recognition and synthesis, and image, audio and video creation.
  • Search models: embeddings for representing and retrieving information, and rerankers for refining result order.
  • Selection criteria: quality on work examples, languages and data formats, context, tool calling, structured outputs, speed and cost. For open-weight models: licensing, hardware compatibility and maintenance.
Model hosting and execution options
  • External API, managed model service, cloud virtual machine, dedicated server, on-premises and hybrid deployments. Choosing according to data, workload, control and availability requirements.
  • A closed environment: network restrictions, permitted external calls, model downloads and updates. Accounting for supporting services — embeddings, speech, telemetry and backups.
  • Local execution and piloting with Ollama and llama.cpp: model downloads, APIs, CPU / GPU execution, weight formats, GGUF and quantisation.
  • Serving under load with vLLM, SGLang and TensorRT-LLM: concurrent requests, batching, memory management and distributing computation across GPUs. Choosing based on compatibility and measured performance.
  • Model access management with LiteLLM: a unified API, routing, keys, limits, cost tracking, retries and fallback routes. Connecting external and self-hosted model services.
  • Enterprise interface with Open WebUI: employee access to permitted models and knowledge. Separating interface hosting, document storage and model execution.
  • Service configuration: weight and engine versions, context and concurrency settings, hardware access, APIs and logs. Deploying separate services or using Docker Compose; an overview of tasks suited to Kubernetes.
Compute resource sizing
  • Workload profile: input and response length in tokens, request frequency and concurrency, and model calls per operation. Accounting for retries, background agents, retrieval, voice and multimodal scenarios.
  • Weight memory: parameter count × bits per parameter / 8. The effect of quantisation on memory and quality; accounting for all stored weights in MoE models.
  • Total memory budget: weights, KV cache for active requests, working buffers and headroom. Effects of context length and concurrency; distribution across GPUs and separate accounting for RAM, CPU and disk.
  • Performance: input processing — prefill — and response generation — decode. Time to first token, generation speed, throughput, queues and p95 latency.
  • Multiple GPUs: distributing one model across accelerators and running independent replicas. Tensor / pipeline parallelism, interconnects and data exchange overhead.
  • Configuration sizing: GPUs per replica based on memory and performance, replica count for peak load, and capacity for failures and growth.
  • Server specification: GPUs and VRAM, compute formats, drivers, CPUs, RAM, SSDs, networking, power and cooling. Additional resources for retrieval, graph memory, embeddings and monitoring.
  • Caching repeated context: reuse conditions, hits and misses, and effects on latency and resources. How prompt caching differs from storing completed answers and long-term memory.
  • Load testing: quality, latency, throughput, errors and memory usage under normal load, peak load and failure. Validating estimates on the selected model and hardware.
Access, administration and operations
  • Permissions for users, administrators and integrations: permitted models, sources and actions. Alignment with permissions in the original enterprise systems.
  • SSO and SCIM: single sign-on and account management where supported by the service. Granting and revoking access, sessions and tokens when an employee's role changes.
  • A shared workspace: publishing Skills, connecting sources and extensions, and managing configurations and quotas. Capabilities of ready-made products and self-hosted solutions.
  • Operations: test and production environments, secrets, logs, monitoring, alerts, backups and recovery. Updating models and components, re-evaluating quality and rolling back.
  • Component ownership, procedures for service unavailability and connecting new initiatives to shared infrastructure.
15

AI economics and pilot implementation

cost estimates, impact validation and transition to operations

2 hours
Business impact and baseline metrics
  • The process baseline: transaction volume, completion time, costs, errors and quality. Measurement period and comparison data.
  • Expected impact: lower costs or increased productivity, revenue or quality. Choosing measurable indicators for a specific initiative.
  • Time saved and financial outcomes: ways to use freed capacity and the conditions under which economic value arises.
Costs and implementation option comparison
  • Total cost of ownership — TCO: development, integrations, data preparation, models, infrastructure, licences, training, support and employee involvement. One-off and recurring expenses.
  • External APIs: input and output tokens, calls per task, retries, embeddings, speech and other services.
  • Self-hosting: CPU / GPU purchase or rental, service life, utilisation and idle time, redundancy, storage, networking, electricity, cooling and support.
  • Comparing options under identical quality, workload and availability requirements. How usage volume affects API and self-hosted service costs.
  • Caching economics: writes and reads, hits and misses, and pricing models. For a self-hosted service, the effect on performance and resource needs.
  • Cost per successful operation: system costs, failed attempts and human review relative to the number of acceptable results. Allocating shared costs without double-counting.
  • ROI and payback period: comparing financial impact with total costs over the same period. Assumptions, uncertainty, baseline and conservative scenarios.
Pilot organisation and evaluation
  • Prototype, pilot and production operations: the purpose of each stage and transition criteria.
  • Pilot boundaries: processes, users, data and features. Timeline, budget, owners, dependencies and checkpoints.
  • Success and stopping criteria: quality, business outcomes, cost, reliability and acceptable errors. Grounds for continuation, refinement or closure.
  • Evaluation plan: solution versions, a Golden Set, real work cases, error logs, feedback and cost tracking. Comparison with the original process.
Employee adoption and ongoing operations
  • Preparing the team: communication, training, new task procedures and user support.
  • Usage metrics: access, activity and return usage by target group, plus source and Skill usage. Period, data source and calculation basis for each metric.
  • Reasons for low usage: access, training, workflow usability, data quality and trust in results. Choosing actions based on statistics and feedback.
  • AI Governance: solution owners, data handling rules, system authority and change approval procedures. Conditions for expanding access and agent autonomy.
  • Operational handover: acceptance, a permanent owner, funding, support and instructions. Updating models, knowledge and Skills, re-evaluation and procedures for quality deterioration.
  • Scaling: onboarding new teams and processes, testing with their data, adapting integrations, recalculating resources and training.
  • Developing the company's AI Stack: reusing proven components, updating priorities and planning subsequent initiatives while accounting for maintenance costs.

Technology stack

The tools
you will learn

From general-purpose models to your own infrastructure. Learn to choose a service for the task and connect it with the rest of the solution.

01

Models and work assistants

Define tasks, compare answers, gather context and configure instructions. Connect work tools and sources to your agent.

  • ChatGPT
  • Claude
  • NotebookLM
  • Manus
02

Automation and corporate knowledge

Build processes in n8n, connect services through APIs and add search over company documents. Check workflow reliability and answer quality.

  • n8n
  • OpenAI API
  • Yandex AI Studio
  • Qdrant
  • Supabase
  • Pinecone
03

Content, multimedia and voice

Connect image and video generation to your workflow. Work with voiceovers, voice agents, editing and media processing.

  • ElevenLabs
  • FFmpeg
  • OpenArt
  • Higgsfield
  • Vapi
  • Remotion
04

Applications and deployment

Use coding agents to work with files, interfaces and logic. Learn version control, testing and application hosting.

  • Claude Code
  • OpenAI Codex
  • Lovable
  • Replit
  • GitHub
  • Docker
  • Vercel
  • Bolt
05

Always-on agents

Configure events, schedules, memory and action controls. Update skills and check how changes affect assistant behaviour.

  • Hermes Agent
  • OpenClaw
  • MCP
  • Hindsight

Also: Skills

Programme experts

Learn from people
who implement AI

Practising instructors with experience in AI product development, machine learning and innovation consulting.

Konstantin Pinchukovsky

Konstantin Pinchukovsky

Co-founder at SkaiLab

  • Co-founder of the SkaiLab development agency and the Practico.ai artificial intelligence school
  • More than 5 years of experience with ML and computer vision IT products in CIS, MENA and US markets
  • Founder of the Credo no-code development agency (2020–2021). Clients included Tinkoff, University 2035, the Moscow Innovation Cluster and HSE University
  • Instructor at HSE University and the SberUp, Archipelago and HSE INC startup accelerators
  • Speaker at Skolkovo, Platforma, Business Gravity and Israel Inspires Me
Mikhail Fridman

Mikhail Fridman

Co-founder and CTO at Osmos

  • More than 5 years in machine learning and computer vision
  • Developed computer vision systems for Disney, Formula E, Games of the Future and Match TV
  • Launched the machine learning startup Osmos and reached No. 1 on Product Hunt
  • More than 10 publications on artificial intelligence in international scientific journals
Yulia Peremitina

Yulia Peremitina

Co-founder at SkaiLab

  • More than 5 years in innovation consulting
  • Former Head of Accelerators at the HSE University Business Incubator
  • Former Innovation Consultant at Startup Lab

Reviews

What participants say

About the instructors, practical work and applying new knowledge on the job.

Lyubov Frolova

PhD in Economics, Director of ISAR, an autonomous non-profit continuing professional education organisation

I am still taking the course at Practico.ai, but I already want to share my feedback. I like the course and it has met my expectations. First of all, the instructors are genuinely engaged and friendly, always ready to answer questions,…
Read the full review

I am still taking the course at Practico.ai, but I already want to share my feedback. I like the course and it has met my expectations. First of all, the instructors are genuinely engaged and friendly. They are always ready to answer questions, help analyse case studies and work with you to build a prototype for your specific automation process. It is very valuable to get a real solution to your own challenges as well as listen to theory.

The programme is substantial and challenging in places. I have not yet managed to implement all the suggested solutions, but at least I can see the possibilities and how to move forward. The sessions are intensive, so set aside time to keep pace. I cannot always manage that, for example, so I watch and work through the recordings afterwards. It is convenient: the material stays available and you can ask questions after watching.

Another advantage is that all the technical issues have already been addressed: VPN access and accounts for AI and automation platforms are provided, so you can study even from Russia without access problems. Overall, the course gives you more than information: it shows you how to make it work in your company.

Vasily Solomkin

IT Project Manager at IBS

The course significantly broadens your understanding of what AI can do. We moved from the straightforward LLM chats everyone understands to building more complex automation workflows that deliver real business value.
Read the full review

The course significantly broadens your understanding of what AI can do.

We moved from the straightforward LLM chats everyone understands to building more complex automation workflows that deliver real business value.

The course has many modules covering different areas of business. If you own a company, that is great: all the use cases will be relevant. If you are an employee like me, even when a particular tool is not directly relevant, you can adapt and configure it to solve your specific problem.

For me, the main value of the course therefore comes down to two things:

1. I can take ready-made AI use cases and simply implement them in my processes

2. I am learning the logic of building AI agents together with automation systems, so I can then figure things out myself and create the tools most relevant to me

Vladislav Eremenko

CEO of Top Credit

I joined this course on the recommendation of a friend who got me excited about the idea that AI could radically improve business processes, especially in sales. I was unsure whether I needed such in-depth training, but decided I would rather…
Read the full review

I joined this course on the recommendation of a friend who got me excited about the idea that AI could radically improve business processes, especially in sales. I was unsure whether I needed such in-depth training, but decided I would rather master this knowledge than let it master me later! The people teaching the course are real practitioners as well as theorists. They provide a HUGE amount of information. Sometimes, with so many case studies, tools and implementation methods, it feels as if your head might explode, especially if you are not from IT. But this is a case where more does not mean worse. Each module is structured, and the instructor always notices when you get stuck and steps in to help. They have never refused a request to discuss a specific situation from our business, even when it meant answering outside working hours or classes.

If, like me, you want to learn from professionals rather than TikTok gurus, this course is definitely for you. Its value exceeds its price, and I am sure it will pay for itself before you even finish it. Thank you for a great experience. I look forward to what comes next! 🚀

Video review of the Practico.ai course

Course fees

One programme.
Two training formats.

Both plans include the complete course. Choose how much support you need when working on your tasks.

01

Practical

The full programme and materials for independent practice.

29 900₽for the complete course

Choose a plan
  • 15 classes / 30 hours
  • Recordings of every class
  • Practical assignments and materials
  • Templates, Skills and code examples
  • Shared participant chat
02

With support

The same programme with additional work on your own tasks.

49 000₽for the complete course

Choose a plan
  • 15 classes / 30 hours
  • Recordings of every class
  • Practical assignments and materials
  • Templates, Skills and code examples
  • Shared participant chat

Additionally

  • 3 private group brainstorming sessions
  • Review of participants' real cases
  • Priority answers from experts
  • Group review of final projects

Your request helps us arrange participation. We will discuss payment and scheduling with you personally.

How to participate

Independently
or through your company

Choose a plan and submit a request. We will clarify the schedule and payment process and answer your programme questions.

I am paying for my training

We will help you choose between independent practice and supported training, explain access to classes and materials, and prepare payment documents.

Choose my plan

My company is paying for training

We will prepare an invoice and contract for the legal entity. If you want to train an entire team, we can discuss a separate corporate programme tailored to your needs.

Request an invoice

Before you start

Common questions

Who is this course for?

For executives, entrepreneurs and professionals who want to apply AI at work, from document analysis and automation to building applications and an implementation plan for their company.

Do I need programming skills?

Development experience is not required. We start with models, instructions and ready-made tools, then cover APIs, Git, coding agents and deployment through training examples. You will need to learn the technical material and reinforce it through practice.

How long is the course?

The programme includes 15 classes of 120 minutes, totalling 30 clock hours. Independent practice is additional. We will provide the start date and schedule when you enrol.

How are classes held?

Online with instructors. Both plans include recordings, practical assignments, materials, templates, Skills, code examples and a shared participant chat.

What will I build in practice?

Configure agents and automations, build a knowledge base and work with voice workflows. Complete a connected project from research and content to an application and its launch. Finally, assess a company initiative, its architecture, resources, economics and pilot conditions.

How do the plans differ?

The Practical plan costs RUB 29,900 and includes the full programme. With Support costs RUB 49,000 and adds 3 private group brainstorming sessions, reviews of real cases, priority expert answers and a group review of final projects.

Can I work on my own tasks?

The programme is built around work scenarios: sales, marketing, documents, corporate knowledge and automation. The With Support plan includes dedicated reviews of participants' real cases and final projects.

Which tools are included in the programme?

ChatGPT, Claude, NotebookLM, n8n, MCP, Codex and Claude Code, application builders, Git and GitHub, Hermes and OpenClaw. We also cover RAG, voice services, model hosting and infrastructure. Each class includes a detailed list.

What should I prepare before starting?

A computer, reliable internet and time for independent practice. You will need accounts for the training services. We will clarify access requirements, technical prerequisites and paid-tool terms before the course starts.

Will I interact with other participants?

Yes. Both plans include a shared chat for discussing tools, sharing experience and asking questions. With Support also includes private group brainstorming sessions reviewing participants' cases.

Can my company pay for my participation?

Yes, enrolment can be arranged through a legal entity. Request an invoice and we will clarify the training format and prepare the documents. A corporate programme for your team can be discussed separately.

How do I enrol?

Choose a plan and leave your contact details. We will contact you, clarify your goals and explain the schedule and payment process. If you are unsure which format to choose, request a consultation.

Your next step

Start applying
AI in your work

Tell us what you do and which problem you want to solve. We will help you choose a format and answer questions about the course.

Back to the programme

Discuss participation

Leave your contact details. We will explain the programme, plans and schedule.

Enter your phone number or email

Get in touch