Andrii Sokolov
Andrii Sokolov
I design and ship production multi-agent AI systems — LangGraph reasoning cores wired to n8n webhooks, Supabase and real business channels.
Founder and sole engineer of AgentUp — an AI automation platform where I built 10 production AI agents, the full website, every automation and the entire database from scratch.
I'm Andrii Sokolov, an AI automation engineer based in Ukraine. I build autonomous AI agents that live inside real business workflows — qualifying leads, generating content, handling support, syncing reviews and orchestrating each other.
My flagship is AgentUp, a full AI automation platform I created and run entirely on my own: a Python/LangGraph reasoning core, n8n as the webhook and I/O layer, a Supabase (PostgreSQL) database I modelled myself, a Chatwoot handoff layer and a hand-coded website with a client cabinet. Every agent, every table, every automation and every line of the frontend is mine.
I care about the parts that make agents actually production-grade: identity resolution across channels, allowlist-based database access, human-in-the-loop confirmation gates, anti-hallucination guards on tool calls and honest live testing against production — not demos that only work on a happy path.
Every AgentUp agent runs on this stack — LangGraph reasoning cores driven by n8n webhooks, backed by Supabase and connected to real channels.
Stateful graphs: context-load → LLM with bind_tools → tools node, with interrupt()-based human confirmation, per-thread failure limits and anti-hallucination guards on tool calls.
n8n as the pure I/O layer — webhooks everywhere: Telegram, Instagram, WhatsApp, Chatwoot and site widgets all flow through n8n into the core. Fan-in workflows, callback routing, credential control.
Self-designed Supabase/PostgreSQL schema — leads, contacts, dm_history, reviews, audit logs — with allowlist access control and a full tool-call audit trail. FastAPI services on Docker.
"One brain, many channels" identity resolution, bridge-token channel merging, IDOR/prompt-injection-safe tool design, HMAC-signed webhooks and stored-XSS hardening.
OpenRouter model tiering (cheap / medium / expensive) with cost-aware routing, Claude & Gemini, FLUX image generation, Tavily web search — matched to each task's complexity and budget.
Hand-coded landing page and client cabinet (no framework): i18n, History-API routing, live Supabase data, billing, realtime chat — plus Docker, Traefik and nginx deploys.
Not a course project. A live platform with a public site, a paying-client cabinet, 10 AI agents and a database I designed — every part built and deployed by me.
An AI automation platform for businesses. I own the whole stack end-to-end: the LangGraph reasoning core, the n8n webhook layer that carries every channel, the Supabase database, the Chatwoot handoff integration, the deploy infrastructure on a Hetzner VPS, and the full website with a self-service client cabinet.
Hand-coded bilingual landing page — no framework, no builder. Chat widget, live Google reviews, GA4, Traefik + nginx deploy.
A full personal dashboard: auth, live data, Paddle billing, file uploads with AI vision, admin inbox, onboarding tour and an AI copilot.
A Supabase/PostgreSQL schema I modelled from scratch: leads, contacts, cross-channel history, reviews, knowledge base and a full audit log.
All webhooks, cron jobs, publishing pipelines, notification fan-ins and channel bridges — orchestrated through n8n and the Python core.
Every one is a LangGraph reasoning core (or n8n AI agent) reached through n8n webhooks. Together they run the whole business — from first DM to closed lead, from content to support.
One agent, one memory across Instagram DM, Telegram, WhatsApp and the website chat. Qualifies leads, answers from the knowledge base, resolves identity across every channel and hands off to a human when ready.
The anonymous AI consultant embedded on the website. Answers visitor questions about the service in their own language and warms them toward a real conversation — no tools, no lead capture, pure Q&A.
Generates posts for Instagram, Telegram, LinkedIn and X — each in its own tone and language — creates images with FLUX, shows a preview with approve / regenerate / cancel buttons, and publishes autonomously on schedule.
Semi-autonomous prospecting: scans Telegram groups on a schedule, scores every message 1–10, verifies businesses with web search, queues candidates for approval and sends outreach through a dedicated userbot account.
The command center in the HQ Telegram group. Reads and writes the database through an allowlist, triggers other agents, generates reports and images, and gates every risky write behind human confirmation.
The "agent inside the agent system": classifies intent from the HQ group and routes each request to the right specialist agent. The dispatcher that makes many agents behave like one coordinated team.
The paying client's private AI chat inside the cabinet. Reads uploaded files with vision (PDF, DOCX, XLSX, images), answers questions about the client's own data and drives their agent configuration.
The cabinet's support channel: an AI first responder that answers technical questions and cleanly hands off to a human through Chatwoot, keeping a single shared conversation history.
A read-only assistant for me as the admin: reads a client's full context and writes onboarding briefs, but by design never writes to the database — a deliberate trust boundary, not a limitation.
Pulls new Google reviews on a cron, deduplicates and stores them in Supabase, notifies the team and feeds the live testimonials block on the website — closing the reputation loop automatically.
The same pattern powers all 10 agents: n8n carries the I/O, a LangGraph core does the thinking, Supabase holds the data, Chatwoot handles human handoff.
load_context → agent (LLM + bind_tools) → tools, looping until done. Every tool call is logged, allowlist-checked and, where risky, gated behind human confirmation via interrupt().
A contacts + channel_identities model resolves the same person across Instagram, Telegram, WhatsApp and the site. Channels merge only through signed bridge tokens — never by guessing.
A single access-control layer decides exactly which tables and fields each agent can read or write. Anything not on the list is physically unreachable — no matter what the LLM is asked to do.
Client-facing agents never take identity from the LLM's arguments — only from verified graph state — closing off IDOR and prompt-injection vectors by construction.
Cheap / medium / expensive model tiers via OpenRouter, chosen per task. Simple classification runs on small models; orchestration and reasoning get the strong ones.
Every feature is tested through the real path against production — real webhooks, real API responses, cleanup verified — not a mock that only passes the happy path.
Designed and shipped a full AI automation platform solo: 10 production LangGraph/n8n agents, a Supabase database, a client cabinet and the whole website. Built the agent fleet on a Python/LangGraph core with identity resolution across channels, allowlist access control and human-in-the-loop confirmation.
Spent the year going deep on the field: LLM APIs and prompt engineering, LangGraph and agent design, n8n orchestration, Supabase/PostgreSQL and the deploy stack — building up the skills that AgentUp is now built on.
Open to AI engineering, automation and agent-development roles — remote or Kyiv-based. Let's talk.