Mark Jherico
Magno

A multi-platform conversation aggregator that pulls inbound messages from four different services into a single dashboard.

The client was managing brand conversations across multiple messaging platforms with different APIs, auth flows, and message schemas. Each platform had its own quirks — one used cookie-based auth with a short-lived token, another required webhook ingestion, a third had a polling-only interface.

• Built normalization layer to unify message schemas across 4 platforms
• Implemented auto token refresh on a 50-minute interval to avoid auth drops
• Per-platform error handling and retry logic for failed message fetches
• Single Express server with platform-specific service modules

An auto-reply bot for a third-party messaging platform that classifies inbound brand messages and responds with smart, context-aware replies.

The client was getting 30+ inbound brand inquiries per day and replying manually, often with delays. I reverse-engineered the platform's internal GraphQL API (cookie auth, undocumented token refresh flow), built a Node.js service that polls for new messages, classifies them by intent, and sends a templated reply customized to the inquiry type.

• Handles 7 distinct inquiry categories (rates, portfolio, booking, retainers, etc)
• Templated responses with LLM-assisted personalization to avoid robotic feel
• Runs 24/7 under PM2 with Slack alerts on errors or auth expiry
• Reduced response time from hours to seconds

// classify inbound message → route to template
async function classifyAndReply(message) {
  const intent = await classifyIntent(message.body);

  if (!TEMPLATES[intent]) {
    await slackAlert('unknown intent: ' + intent);
    return;
  }

  const reply = await personalize(TEMPLATES[intent], message);
  await sendReply(message.threadId, reply);
  log({ intent, threadId: message.threadId, at: Date.now() });
}

A rule-based agent that filters inbound campaigns from a creator marketplace and auto-applies to qualified ones, then pushes summaries to Slack.

The marketplace had hundreds of new campaigns daily, most of which didn't match the client's criteria. Reviewing manually was eating into actual creative work time. I built a worker that pulls new campaigns on a schedule, runs them through a strict rule filter, applies to the qualified ones via the platform's internal API, and posts structured summaries to Slack for the team to review.

• Strict rule-based filtering — no AI hallucination risk on apply decisions
• Structured Slack summaries grouped by campaign type
• Audit log of every application sent, for client review
• Automated 200+ daily evaluations down to ~10 actually-relevant applications

An end-to-end AI video production pipeline that takes a topic and produces a finished MP4 — script, voice, avatar, images, animation, and assembly — with one command.

Built for a client running a faceless YouTube channel. The pipeline needed to match a specific scene grammar: avatar appears 2-4 seconds, switches to zoomed still images, animated clips, and split screens — all cutting on natural voiceover pauses detected from ElevenLabs speech alignment data.

• Claude API generates the script; ElevenLabs (Daniel voice, turbo model) produces voiceover with word-level timestamps
• Natural break detection parses alignment data to find speech pauses — every scene cut happens exactly there
• FLUX Pro generates images using a 2014 smartphone aesthetic prompt + 8-photo reference grid
• Hedra API produces the AI avatar clip (4 seconds max, with audio compression to reduce mouth exaggeration)
• Kling animates every 3rd image; FFmpeg pre-renders each scene clip then concatenates with audio into final MP4
• Scene grammar enforces: avatar open → ken burns → animated → split screen → repeat, max 3 avatar appearances per 60s

// one command → finished MP4
const script   = await generateScript(topic);
const voice    = await generateVO(script, audioPath);
const scenes   = getSceneDurations(voice.alignment);
const images   = await generateImages(topic, count);
const avatar   = await generateAvatar({ imageBuffer, audioBuffer });
const animated = await animateImages(images);
await assembleVideo(scenePlan, audioPath, outPath);