Nujoom docs

Nujoom is an AI Growth Operating System for creators and businesses. Not a content generator. Not a scheduling tool. Not a CRM. An operating system: the place you open every morning that already knows what happened overnight, what worked, what your audience is asking about, and what to publish next — with drafts already written.

The goal is that you never need to leave Nujoom to grow your brand. It replaces the daily mash of ChatGPT + Buffer + ManyChat + Metricool + trend trackers + spreadsheets + scattered notes with one workspace that has all of that functionality wired into a single compounding intelligence loop.

The important word above is compounding. Every metric that lands, every DM that comes in, every trend that surges gets folded back into what Nujoom knows about your niche and your voice — and every downstream generation gets a little sharper the next day. Most tools decay over time because static prompts get stale. Nujoom is designed to do the opposite: get sharper every week.

Every feature answers one of four questions:

• What should I create? — Intelligence + Strategy
• Create it for me. — Creative
• Get me customers. — Publishing + DM Automation
• How do I improve? — Growth + Analytics

When a feature stops clearly answering one of those four, it's outside Nujoom's scope. That's why Nujoom does not try to be a project manager, a Notion clone, a help-desk platform, or a generic CRM — those tools do not reduce the friction of growing a brand.

The /today page is the surface you open every morning. It is a briefing, not a dashboard. Structure:

1. Overnight snapshot — a strip of seven tiles with 24-hour counts: New DMs, Leads captured, Agent reports, New learnings, New signals, Opportunities, Trend drafts. Each tile is a launcher — click it and you land on the surface where you can act on the number.
2. Human takeover alert — if any DM conversations are marked for human handling, a shortcut surfaces prominently.
3. Your crew ran overnight — every scheduled or chained agent run in the last 24h with its trigger badge, status, one-line summary, and full output on click.
4. Fresh learnings overnight — auto-distilled observations Nujoom wrote to memory in the last 24h.
5. Your audience is asking about — top topics from the last 7 days of DM classification.
6. Trend drafts waiting for you — up to two starter posts Nujoom wrote overnight based on trends that crossed the velocity threshold. Each is pre-scored by the predictor.
7. Focus, Intent, Trending in your niche, Recommendations, Ideas, Waiting drafts, What I learned this week.

Everything in Nujoom feeds one loop. Understanding it is worth the two minutes it takes.

1. Ingest. Every 30 minutes a Cloudflare Worker fires the Vercel cron endpoints, which pull fresh signals from your configured sources (Google Trends, HackerNews, RSS, Instagram, TikTok) and refresh metrics on your published posts.
2. Annotate. Every 4 hours the annotator enriches raw signals with topic tags, quality scores, and summaries.
3. Cluster. Similar signals collapse into trend clusters ranked by velocity (surging vs steady vs dying).
4. Synthesize. Every 6am UTC the synthesizer turns clusters + memory + brand context into opportunity cards.
5. Draft. Any cluster over the velocity threshold becomes an auto-drafted post in the Studio, pre- scored by the performance predictor.
6. Publish. You approve or refine, schedule, publish (natively on IG / LinkedIn / Threads / TikTok).
7. Engage. Comments trigger auto-DMs. DMs route through your automation flows. Each conversation is classified for sentiment + topic every hour.
8. Convert. Qualified leads carry their source attribution back to the exact post that generated them. Deal value tracked. Every touchpoint in the timeline.
9. Measure. Every hour, prediction reconciliation compares predicted vs actual engagement on published posts, writes the delta as a durable lesson.
10. Learn. Every 6am UTC, the learning writeback distills the previous 24h into 3-6 durable observations in memory.
11. Improve.Every downstream generation — Studio, Hook Lab, Agents, Advisor, DM AI replies — reads those learnings before answering. Tomorrow's output is a little sharper. Loop.

The raw feed. Every scrape / pull / API call from every configured source lands here as a signal row. Each signal has: source_kind, title, body, url, author, engagement fields, posted_at, and raw metadata.

How it works. The signals table is workspace-scoped. Ingestion is idempotent: a unique index on (workspace_id, source_kind, external_id) prevents duplicates across ticks. Fresh signals are embedded post-insert so semantic search on the feed and the LLM annotator both have vectors to work with.

UI. Intelligence → Signals. Shows recent signals grouped by source with a search + status filter (annotated vs raw). You add or remove signal sources here. Each source row shows last_synced_at and any last_error so you can diagnose broken configs.

Five source kinds are wired today. Every workspace has zero sources by default — you add whatever matches your niche.

Reddit sources (reddit_subreddit, reddit_search) are wired but need Reddit OAuth because Reddit's Responsible Builder Policy now blocks unauthenticated JSON access. An RSS fallback exists but gets rate-limited by Vercel IPs. Enable by registering a Reddit app + setting REDDIT_CLIENT_ID + REDDIT_CLIENT_SECRET on Vercel.

The annotated view. Every 4 hours the LLM annotator reads new signals and enriches them with a topic tag, quality score, and short summary. The Feed page shows the enriched versions grouped by topic — the raw signals hang out on the Signals page.

What you do here. Skim topics to spot what is bubbling in your niche. When something catches your eye, click Draft to jump into the Studio with that topic as the brief.

Signals get clustered by hashtag / topic / audio / author. Any cluster with real velocity (surging vs steady vs dying) ranks up. Ranking formula is velocity × sample_size × sqrt(engagement).

Special handling for Google Trends.Because each Google Trends signal is unique-by-title (banana, budget…), the "need 2+ signals to be a cluster" rule would filter them all out. Nujoom bypasses that: google_trend signals become their own single-signal clusters with high velocity because they are trends by construction.

The list of accounts you actively watch. Each row has a name, notes, website, and platform handles (Instagram currently — LinkedIn / TikTok can be added as text notes until dedicated fields land). Nujoom pulls AI summaries per competitor on demand and can generate content suggestions derived from what they're doing that you aren't.

Competitor Instagram reel scraping + audio transcription + hook / structure analysis. Uses two integrations: Monid for scraping (via TikHub's Instagram user_posts endpoint, filtered to is_video: true) and ElevenLabs for speech-to-text on the mp4.

How it works. You add competitors first (Intelligence → Competitors). On the Reels page, click Scrape latest. Nujoom pulls the last N reels per competitor, downloads each mp4, sends it to ElevenLabs for transcription, then runs a scoring LLM that extracts hook style, structural beats, and angle. Results land in competitor_reels and reel_analyses.

Realistic cost. At 5 competitors × 3 reels × weekly refresh: Monid ~$0.18/mo, ElevenLabs free tier covers the transcription.

The setup + metrics command surface. Shows the state of every prerequisite in one place: Brand HQ filled, strategy mode picked, focus set, platforms connected, signal sources active, agents created, competitors added. Nujoom uses this page as the definitive checklist before onboarding is considered done.

One per workspace. Every AI response is tuned by the picked mode — hook picks, calendar cadence, agent recommendations. Eleven modes:

• growth — reach + follower growth. High-hook, share-worthy content.
• authority — perceived expertise. Sharp POVs, contrarian takes.
• education — pedagogy. Tutorials, frameworks, step-by-step.
• entertainment — enjoyment + share value. Stories, humor, character.
• lead_generation — qualified leads. Problem-agitation, case studies, results-forward.
• community — engagement + reply depth. Questions, opinions, invitations.
• launch — every recommendation ladders to an active launch cycle. Tease → proof → CTA → recovery.
• newsletter — email subscribes. Lead-magnets, list-worthy takes.
• personal_brand — founder equity. First- person stories, opinions, behind-the-scenes.
• local_business — local discovery. Location cues, community shoutouts, offers, local testimonials.
• custom — follow the workspace strategy_context notes verbatim.

An explicit statement of what you're currently trying to do. Overrides the strategy mode's default lens for the focus window. Example: “Launching v2 of my course this Friday — every post should ladder to the waitlist.”

Set on the Today page. Every AI prompt from the moment you set it treats the focus as top priority and biases suggestions to advance it.

Your content pipeline: idea → draft → scheduled → published. Content pieces created in the Studio land here as draft rows. Scheduling a piece writes a content_calendar entry with scheduled_for, which the publish-queue cron later executes against the connected channel.

Views. Week grid, month grid, list. Filter by platform. Drag to reschedule (where UI supports it).

Pick kind (hook, title, caption, script, post, thread, ad, description, blog, email…) plus platform, type a brief, hit Generate. For multi-item kinds (hooks / titles / captions), Nujoom returns 5 variations in one call.

How it works. Every generation loads the full workspace lattice via loadFullWorkspaceContext: brand voice, positioning, pricing, objections, FAQs, competitors, knowledge, formulas, memory (manual + auto-learnings), Content Genome, focus, recent ideas, top trends. The prompt is assembled by buildNujoomSystemPrompt which enforces:

• Concrete, workspace-specific answers.
• Brand voice always.
• Bias toward Content Genome winners (hook styles, voice traits, topics).
• Weight auto-learnings highly — they are data-derived from your metrics, funnel, and trends.
• Cite specific frameworks over vague advice.

One brief → a truly platform-native draft on each surface you check. Not a text-adapt of a single source. Each draft is generated independently with a platform-specific recipe.

Recipes.

• Instagram — punchy first line, short paragraphs, 3-5 native hashtags. 800-1300 chars.
• TikTok — spoken 30-45s script with a 2-second hook, 3-5 beats, soft CTA, then a CAPTION: line.
• LinkedIn — line-break heavy for algorithm love, story or data point, reflection question at the end. 1200-1800 chars.
• X — numbered thread with each post ≤ 280 chars, separated by ---.
• Threads — short conversational replies separated by ---.
• YouTube — SEO-woven description with 4-6 keywords, 500-900 chars.
• Blog — full markdown with H2 subheads, 600-1000 words.
• Email — SUBJECT: line + newsletter body, 300-600 words.

All generations run in parallel via Promise.allSettledso one broken platform doesn't kill the batch. Each successful draft carries meta.source = "cross_platform" and gets a cross-platform badge in the Studio history.

Every Studio draft has a Predictbutton. Click it and Nujoom scores the draft 0-100 versus this creator's baseline (not versus internet-average — versus your Content Genome).

Grounded in. Content Genome (voice fingerprint + hook mix + winner delta), growth insights (last 30d winners + hook leaderboard), external trends (top 5 by velocity), community topics (audience DM asks last 7d), auto-learnings.

Output. Score + bracket (below_baseline / at_baseline / above_baseline / breakout) + confidence (low/medium/high) + strengths (max 4) + weakness-and-fix pairs (max 4) + one-sentence reasoning.

The predictor scores its own predictions. Every 30 minutes, the reconciliation pass finds predictions whose linked content has metrics ≥24h old, computes actual engagement score using the same formula as the hook leaderboard, and writes it back onto the prediction row.

Then the model distills the delta into one durable lesson (200 chars) which gets written to ai_memory with source=auto_learning. That lesson feeds into every future generation. Hit or miss, the loop closes.

What you see. Studio cards for reconciled drafts show two chips: predicted 68 and actual 74 (+6), colour-coded green if the predictor hit, rose if it missed. Hover the actual chip for the reconcile timestamp.

Every daily 6am UTC tick, Nujoom scans trend clusters and picks up to 2 that cross both thresholds: velocity ≥ 0.65 AND sampleSize ≥ 5. For each, it generates a starter post using the same generation lattice as manual Studio drafts, then runs the predictor.

Dedup. contents.meta.trend_key is checked for the last 7 days so the same trend doesn't spam the Studio on repeat ticks.

Drafts land with a trend auto badge and a hover-title showing the source cluster. The Today morning brief lists them as clickable rows.

Score any hook against your Content Genome baseline before you commit. Enter a hook, get scored on: pattern-match with your winners, tension, specificity, voice consistency, promise strength. Suggestions come back with rewrite variants tuned to your top-performing hook style.

Reusable content templates. A formula is a {hook, story, cta, framework} tuple with a name. Nujoom either uses formulas verbatim or extends them with new instances. Studio prompts reference saved formulas as candidate scaffolds.

Multi-step deterministic sequences that produce a full output. Two ship today:

• Draft post — brief → hook variants → scored → best hook → full draft. Multi-step; each step logs to agent_step_logs.
• Plan week — reads focus + calendar + recent trends → outputs a 7-day content plan (pillar + supporting posts + experiments).

Both wrap loadFullWorkspaceContext + buildNujoomSystemPrompt so they inherit brand voice + learnings without extra wiring.

Where you connect the platforms Nujoom publishes to. Supports LinkedIn, Threads, TikTok, Instagram out of the box. Each uses native OAuth via the platform's official Publishing API — no scraping, no proxies. Nujoom stores access_token + token_expires_at per connection in platform_connections.

• Instagram — Business Login flow. Enables publishing + DM automation + comment triggers + Send API. Requires Meta app review for instagram_business_manage_messages scope (~2-4 weeks) before DMs work in production.
• LinkedIn — Personal or company profile. Requires w_member_social.
• Threads — Meta Threads API. threads_basic + threads_content_publish.
• TikTok — Content Posting API. Video only. App review needed for prod (sandbox works for testing).

Scheduled content items sit in content_calendar. Every 30 minutes, the publish-queue cron finds items whose scheduled_forhas passed, calls the appropriate platform's Publish API, and updates the row with published_at or an error message. Failed jobs retry with exponential backoff (state stored in publish_jobs).

Instagram DM flows built without SQL. Each automation has a trigger (any_dm, first_dm, keyword, story_mention, story_reply, comment_reply, ad_reply, referral) and a flow of typed steps.

Step kinds.

• send_text — a text message. Supports {{field_name}} interpolation.
• send_link — text + URL (delivered as generic template).
• send_buttons — text + up to 3 quick-reply buttons.
• ask_field — ask a question, save the reply into conversation state under a field name.
• qualify — AI scores the conversation 0-100 against your criteria, creates or updates a lead.
• handoff — stops the flow, marks conversation awaiting_human.
• ai_reply — free-form AI reply using Brand Brain (voice, pricing, objections, FAQs). Full conversation history included.

Templates. Five pre-built starters — Welcome DM, Follow-gated download, Keyword auto-reply, Lead qualifier + handoff, AI Concierge (pure AI). Pick one, edit anything.

Two-pane inbox: conversation list on the left, transcript on the right. URL-driven selection (?c=...). Status filter (all / active / awaiting user / human / done) + username search. Full message history with sender-colored bubbles (user / automation / AI / human).

Human takeover. Toggle on any conversation and the automation stops responding. Type your own message in the composer; Nujoom sends it via the IG Send API and records it in the transcript with sender=human. Toggle off to hand back to automation.

Every inbound DM gets classified by the daily cron for sentiment (positive / negative / neutral / mixed) + a 1-4 word topic phrase (pricing question, shipping delay, compliment, refund request…).

Where you see it.

• Publishing → Community — sentiment bars, top 12 topics with counts + sentiment breakdown + sample quotes.
• Today morning brief — “Your audience is asking about” chip row.
• Every agent's DM brief includes the same aggregates, so Sales / Community Manager / Support agents draft replies grounded in real audience pulse.

Every qualified conversation creates a lead. Each lead has: captured fields (email, phone, custom fields from ask_field steps), qualified_score (0-100 from the qualify step), status (new / qualified / booked / converted / lost), deal value (expected + actual + currency), source attribution (which content piece drove them here), first_touch_at, converted_at, activity timeline.

Pipeline dashboard. Card at the top of the Leads page: Open pipeline value ($), Converted revenue ($), Avg deal size ($), Top source content. Currency-aware formatting.

Timeline. Every status change, note edit, deal update, currency change, attribution change, and manual event lands in dm_lead_eventswith a kind badge. Free-form “Log a manual event” input for meetings, calls, offline signals.

The complete flow, top to bottom, from a public IG post through to a converted customer with full attribution:

1. You publish an IG reel via the Studio.
2. Someone comments “LINK” on the reel.
3. Meta's webhook fires our /api/webhooks/instagram endpoint with the comment event.
4. Nujoom looks for a comment_reply automation on the account with matching keywords. Match found.
5. Nujoom private-replies to the comment via Meta's Private Reply API (recipient.comment_id). That opens a DM conversation with the commenter.
6. The automation flow continues — first message stored, then subsequent user replies advance the flow. Say the flow asks for email + budget.
7. User provides both. Automation reaches its qualify step. AI scores them 82/100.
8. Lead created. Nujoom looks up publish_jobs.external_post_id = media_id (the reel's media id, stored on the conversation from step 4). Match found. Lead gets source_publish_job_id + source_content_id stamped.
9. You take the lead through your sales process. Move status through qualified → booked → converted. Enter actual deal value $2,400.
10. Pipeline dashboard shows: “$2.4k closed. Top source: Reel about pricing tiers.”
11. That attribution rolls into the learning writeback the next day → future generations know that reel-about-pricing content converts.

Specialized AI teammates that share workspace context — not isolated chats. Every agent knows your brand, voice, metrics, funnel, learnings. They can cooperate (chain outputs into each other) and run on schedules.

Eight prebuilt starters:

• Content Strategist — weekly plan grounded in winners + trends.
• Growth Advisor — weekly review with the single lever to pull.
• Trend Hunter — surfaces viral formats with your angle.
• Sales Agent — prioritizes leads, drafts opening DMs.
• Community Manager — drafts warm human- tone DM replies.
• Competitor Watchdog — flags what tracked competitors changed.
• Customer Support — answers FAQ-flavored DMs from brand info.
• Research Agent — deep-dives a topic with cited evidence.

Every template is a fork point. Rename, rewrite the system prompt, change tools, alter the schedule.

Each agent has a checked list of read-only tools. Only checked tools' data slices are loaded at runtime — keeps prompts small, enforces permissions by construction.

• read_brand — voice, positioning, pricing, objections, FAQs.
• read_metrics — KPIs, winners, hook leaderboard, platform mix (30d).
• read_signals — trend clusters (hashtags, topics, audio, authors).
• read_dms — recent conversations + funnel counts + community sentiment.
• read_leads — captured leads with qualification scores.
• read_calendar — scheduled + published items last 30 days.
• read_competitors — tracked competitor list + recent reels.
• read_ideas — recent ideas from your Idea Inbox.
• read_memory — prior AI memory + auto-learnings.

Every agent has a Hands off todropdown. When the agent finishes, its output becomes the input for the picked next agent. Chain depth is capped at 5 server-side so a bad config can't loop.

Enter a 5-field cron string. Nujoom fires one workspace tick per day at 6am UTC (Vercel Hobby limit) and one lightweight tick every 30 minutes (via Cloudflare Worker). Weekly cadences respect the day-of-week field, so 0 8 * * 1 fires on Mondays only.

Multi-hour scheduling lands when the Vercel plan upgrades unlock more cron slots.

After each successful run, Nujoom extracts a 1-line takeaway (200 chars, no fluff) and writes it into ai_agent_memory. Every future run of that agent reads its own memory back into the prompt, so the agent gets sharper about its own patterns over time.

Forget-one and Forget-all controls live on the agent page.

The analytics command center. Six KPI cards (Views, Likes, Comments, Shares, Saves, Followers Δ) with period-over-period delta (last 30d vs prior 30d). Below: top winners with hook style + topic tags, hook style leaderboard by avg engagement, platform mix, best posting windows heatmap, external trend clusters.

Streaming AI companion for the analytics dashboard. Six quick-questions plus free-form input:

• What should I post tomorrow?
• Which hook is winning for me?
• Why did engagement drop?
• Which platform deserves my attention?
• What CTA is converting best?
• How can I increase conversions?

Two-lens prompt.The Advisor is required to merge internal (this creator's metrics, funnel, genome, memory) with external (trends, competitor signals) before recommending. Output structure enforced: Answer → Internal signal → External signal → Do this next (with platform + timing).

Per-post metrics table. Every published piece with its latest engagement numbers pulled by the refresh-metrics cron every 30 minutes. Sortable by score, views, likes, comments, saves, shares, retention_pct.

The distilled fingerprint of what has worked for you. Extracted from every published post by the extract-genomes cron. Contains:

• Voice fingerprint — formality, energy, second-person density, contraction rate, emoji density, avg sentence length, question ratio.
• Hook mix — which hook styles you use and in what proportion.
• Recurring topics — the tag cloud of what you talk about.
• Winner delta — how your top-25% posts differ from the rest (hook style, formality, energy, second-person). Reveals what your best pieces do differently — biasable in future generation.

The Genome flows into every generation prompt via buildNujoomSystemPrompt. Also drives Hook Lab scoring, performance prediction, and trend-draft generation.

The workspace's canonical brand block. Name, mission, positioning, brand voice, website, pricing, common objections + rebuttals, FAQs. Feeds every AI prompt so the model doesn't need to be re-told who you are on every call.

Pricing + objections + FAQ are what let AI DM replies actually answer customer questions correctly. Fill these in for the biggest DM-automation quality jump.

Raw thoughts you drop in as you have them. Not content — just seeds. Every AI prompt reads your recent ideas and biases generation toward things you actually want to talk about, not what a generic model would suggest.

Ideas can be tagged with a content pillar. Turning an idea into content moves it from raw to organized to drafted to published.

Upload PDFs, paste URLs, drop docs. Nujoom embeds each source and injects the most relevant chunks into generation prompts when the semantic distance justifies it. Great for product docs, brand guidelines, case study collections.

The compounding half of the Growth OS. Every daily cron tick, Nujoom reads the last 24-48 hours of activity — growth insights, DM funnel, top trend clusters, yesterday learning log — and asks the model to distill 3-6 durable observations.

Rules enforced in the prompt:

• Grounded strictly in the numbers/facts provided.
• Merge internal + external whenever both exist.
• Each learning is a single terse sentence.
• Skip anything already in prior learnings — no restating.

Written to ai_memory with source=auto_learning. Loaded separately from manual/chat memory into every prompt as a titled block (“What Nujoom has learned recently”) framed as data-derived evidence, not preferences.

UI. Memory → Learnings shows the log filtered by kind (brand / audience / content / analytic / etc.) with counts + Refresh now + forget-one controls.

Two surfaces, one engine:

• Drawer — press ⌘J anywhere in the app. Right-side sheet with an ephemeral chat that gets a fresh conversationId per open. Great for a quick ask without leaving the page.
• Standalone /ask — full-page threaded chat with a conversation history sidebar. Every exchange saves. Rename or delete threads from the sidebar.

Both use the same streaming endpoint (/api/chat) which loads loadFullWorkspaceContext and streams the response. After each exchange, a memory extraction pass runs (via after() so it never blocks the stream) that distills durable facts from the conversation into ai_memory.

A tiny Cloudflare Worker fires the Vercel cron endpoints on three tempos:

• Every 30 minutes — ingest signals, refresh metrics, process publish queue, lightweight synth (community-analyze + reconcile predictions + scheduled agents matching today).
• Every 4 hours — annotate signals, extract genomes.
• Daily at 6am UTC — full daily tick (opportunity synth + learnings writeback + trend auto-drafts).

Why Cloudflare? Vercel Hobby caps at one daily cron. Cloudflare Workers has unlimited cron triggers on the free tier (100k requests/day; we use ~25/day). The Worker just HTTP-fetches the Vercel endpoints with a bearer secret; all business logic stays on Vercel.

A design rule baked into every AI prompt. Nujoom mustalways merge two lenses:

1. Internal— what this specific creator's own data shows (Content Genome, winners, funnel, memory).
2. External— what's trending across the internet (signal clusters, competitor cues, viral formats).

Single-lens responses are the failure mode Nujoom is designed to avoid. Every recommendation should name both signals before proposing an action. Example of the target voice:

“Story hooks are running 40% ahead of your list hooks for the last 30 days. At the same time, behind-the-scenes is trending across LinkedIn this week. Combine the two: a story hook set inside a BTS moment. Post Tuesday morning — your Tue 8-12 window has your highest avg engagement.”

Every commercial event ties back to the content that drove it. Data model:

• contents — the piece you published.
• publish_jobs — the platform-side publish record with external_post_id (IG media id, LinkedIn URN, etc.).
• dm_conversations.state.media_id — the reel/ post id if the conversation started from a comment.
• dm_leads.source_content_id + source_publish_job_id — filled at the qualify step by joining conversation state to publish_jobs.
• dm_leads.deal_value_actual + converted_at — filled when you close the lead.

The Leads pipeline dashboard aggregates converted revenue per source_content, so you can see: Reel X → 12 leads → $8k closed.

Every generation surface — Studio, Cross-platform, Hook Lab, Formulas, Calendar planner, Cockpit, Refine, Reels analyzer, Competitor suggestions, Chat, Growth Advisor, DM AI reply, Workflows — uses buildNujoomSystemPrompt. That function receives autoLearnings as a dedicated param and renders them in a titled prompt block:“What Nujoom has learned recently (data-driven observations)”.

The prompt's directives include: “Treat them as evidence, not preferences. Prefer recommendations that either extend a winning pattern or address a losing one flagged below. When they exist, weight them highly — they are data-derived from THIS creator's own metrics. Cite one when it directly informs your answer.”

Net effect: every day the learning writeback fires, tomorrow's content gets sharper — without touching prompt code.

Instagram Business Login (2024+ direct IG OAuth, not FB Login). Scopes: instagram_business_basic, instagram_business_manage_messages, instagram_business_content_publish, instagram_business_manage_comments.

What Meta powers.IG DM automation, comment triggers, story replies + mentions, content publishing, webhook receiver. All via Meta's official APIs. Requires Meta app review for the messaging scope (~2-4 weeks) before production DMs work.

Marketplace that aggregates scraping providers (TikHub, Apify, and others) behind a unified async run API. Environment: MONID_API_KEY. Base: https://api.monid.ai. Auth: Bearer.

Contract. POST /v1/run starts a run; GET /v1/runs/{id} polls until COMPLETED / FAILED / STOPPED / BLOCKED / TIME_OUT. Nujoom uses fire-and-poll with 1.5s interval + 45s timeout.

What Monid powers today. Instagram hashtag + account signal sources; Instagram user_posts for competitor reels; TikTok hashtag (via video search endpoint) + TikTok account. Costs: $0.0015-0.003 per call.

Speech-to-text for competitor reel audio. Environment: SUPADATA_API_KEY. Accepts the Instagram reel URL directly (no need to hand-hold a downloaded video), and uses native captions when available before falling back to AI generation. Realistic monthly spend at 5 competitors × 3 reels × weekly = free tier.

Lives in cron-worker/. Two files: wrangler.toml (three cron triggers + NUJOOM_URL var) and src/worker.ts (dispatches triggers to Vercel endpoints in parallel via Promise.allSettled). Secret: CRON_SECRET, set via wrangler secret put.

Deploy in three commands after cloning: npm install · npx wrangler login · npx wrangler deploy. Full setup in cron-worker/README.md.

Postgres + Auth + Storage + pgvector for embeddings. Environment: NEXT_PUBLIC_SUPABASE_URL, NEXT_PUBLIC_SUPABASE_ANON_KEY, SUPABASE_SERVICE_ROLE_KEY. RLS is enforced on every table via a workspace-membership helper:

create policy "table_name: rw member" on public.table_name
  for all
  using (private.is_workspace_member(workspace_id))
  with check (private.is_workspace_member(workspace_id));

OpenRouter routes to whichever LLM is cheapest+fastest for the task (text, reasoning, vision). OpenAI powers embeddings for signals + knowledge + memory (text-embedding-3-small, 1536 dimensions).

Environment: OPENROUTER_API_KEY, OPENAI_API_KEY. Model selection lives in src/lib/ai/router.ts.

1. Intelligence → Competitors → Add competitor.
2. Fill in name + Instagram handle (without @). Save.
3. Intelligence → Signals → Add source → Instagram account. Enter the same handle. Save.
4. Wait up to 30 minutes for the next ingest tick, or fire manually via the Cloudflare Worker's bearer-scoped GET endpoint.
5. Their recent posts appear on Signals + Trends. Their reels (if any) get pulled + transcribed + analyzed on the next Reels scrape.

1. Connect at least one publishing channel so metrics land (Publishing → Channels).
2. Add 3-5 signal sources across kinds — a Reddit-adjacent (Hacker News top), Google Trends US, and 2-3 RSS feeds of publications in your niche.
3. Create at least one competitor + one Instagram hashtag source in your niche.
4. Home → Agents → New → Content Strategist template. Set schedule 0 8 * * 1 (Monday 8am UTC).
5. Fill Brand Identity + set a Focus. This is what makes generations specific.
6. Wait a day. Next morning: overnight brief with agent output, fresh learnings, community topics, trend drafts.

1. Publishing → Channels → connect Instagram Business account.
2. Publishing → DM Automations → New from template → “Follow-gated download” or “Lead qualifier + handoff”.
3. Change trigger kind to Comment reply. Set keywords (e.g. LINK, guide, info). Leave blank to trigger on any comment.
4. Edit the flow: adjust the first message, add or remove ask_field steps, tune the qualify criteria.
5. Activate. Publish a post via Nujoom mentioning the keyword in your CTA.
6. When someone comments the keyword, Nujoom private-replies → opens a DM → runs the flow → creates a lead with source attribution tied to that specific post.

Build three agents that hand off to each other in sequence.

1. Create Trend Hunter from template. Schedule 0 6 * * 1.
2. Create Content Strategist from template. No schedule (fires only via handoff).
3. Create Community Manager from template. No schedule.
4. Edit Trend Hunter → set Hands off to = Content Strategist.
5. Edit Content Strategist → set Hands off to = Community Manager.
6. Monday 6am UTC → Trend Hunter fires → its output feeds Content Strategist → its output feeds Community Manager → three coordinated agent reports land in the Today morning brief, all traceable via the chain badges on the run rows.