# Mohammad Jazim AI Product Leadership | Healthcare AI | Agentic Systems | Product Strategy - Site: https://mohammadjazim.blog/ ## The AI Profitability Paradox: When More Users Don’t Mean More Profits - Link: https://mohammadjazim.blog/2026/11/06/ai-profitability-paradox-users-profits/ - Published: 2026-11-06T02:41:27+05:30 - Author: Mohammad Jazim **AI is becoming cheaper to run, yet increasingly expensive to operate. The next competitive advantage may not be intelligence alone, but the economics of delivering it.** _By Mohammad Jazim | AI Product Strategy_ ## The Statement That Should Make AI Product Leaders Think On November 1, 2026, Elon Musk made an interesting admission about Grok Bot. > “The cost of serving Grok Bot was unsustainably high relative to revenue.” The statement came amid complaints from users who were exhausting their usage allowances sooner than expected. What makes this interesting isn’t necessarily the company or the product. It’s the underlying economics. For years, the technology industry has operated on a relatively straightforward assumption: build a great product, acquire users, scale infrastructure, and eventually improve margins through economies of scale. Traditional software-as-a-service businesses have often benefited from this model. Once the software exists, serving additional customers can be relatively inexpensive compared with the revenue they generate. AI complicates that equation. Every model invocation consumes computation. Every additional reasoning step increases resource utilization. Every autonomous agent potentially introduces multiple model calls, tool executions, context retrieval operations, and retries. The system doesn’t simply serve the customer. It performs computational work on the customer’s behalf, sometimes continuously. And that creates an uncomfortable possibility: An AI product can grow rapidly, attract millions of users, generate substantial revenue, and still have unsustainable unit economics. The distinction between adoption and profitability is becoming one of the most important conversations in AI product strategy. ## The Research Reveals a Contradiction Here’s where things become particularly interesting. AI inference is becoming significantly cheaper. According to Stanford’s 2025 AI Index Report, the cost of querying a model with performance equivalent to GPT-3.5 on the MMLU benchmark declined from approximately $20 per million tokens in November 2022 to just $0.07 by October 2024. That’s a reduction of more than 280 times in approximately 18 months. An extraordinary improvement. Yet companies continue to face enormous infrastructure and inference expenditure. How can both things be true? Because reducing the price of an individual unit of computation doesn’t necessarily reduce the total computation consumed. As AI becomes more accessible, organizations introduce it into more workflows. Applications become increasingly sophisticated. Models process larger contexts, perform deeper reasoning, and execute increasingly complex tasks. A chatbot that once generated a single response can evolve into an agent that independently executes dozens of actions. The cost per token is falling, but the number of tokens required to deliver certain outcomes can increase dramatically. This distinction matters. We’re witnessing two competing forces: declining computational prices and expanding computational consumption. The financial outcome depends on which force dominates, alongside the revenue and value generated. ## What Stanford’s Research Tells Us About AI Agents A 2026 study associated with Stanford’s Digital Economy Lab, titled How Do AI Agents Spend Your Money? Analyzing and Predicting Token Consumption in Agentic Coding Tasks, investigated how AI agents consume tokens. The researchers analyzed execution trajectories from eight frontier language models performing software engineering tasks. Their findings were revealing. In the workloads studied, agentic tasks consumed approximately 1,000 times more tokens than conventional code reasoning and chat interactions. Even more interestingly, repeated executions of the same task could differ by as much as 30 times in total token consumption. And greater token consumption did not consistently produce better outcomes. In some cases, accuracy peaked at intermediate expenditure levels before additional computation delivered diminishing returns. The researchers also found that models struggled to predict their own token consumption before performing tasks. These findings come from agentic coding workloads and should not be interpreted as universal cost multipliers across every industry. Nevertheless, they highlight a fundamental challenge. We are increasingly deploying systems whose computational expenditure is difficult to predict, even when the underlying task remains unchanged. Consider what this means for an enterprise AI product. A customer might pay a fixed subscription fee. But the computational effort required to serve that customer can vary substantially depending on how they use the product. One user submits straightforward questions requiring minimal reasoning. Another executes complex, multi-step workflows that require repeated retrieval, analysis, validation, and tool invocation. Both may generate similar subscription revenue. Yet their serving costs could be dramatically different. This makes traditional subscription pricing more complicated. It also introduces a new product management challenge: predicting and controlling the economics of autonomous workflows. ## The $600 Billion Question Was Never Just About Infrastructure In June 2024, Sequoia Capital’s David Cahn published AI’s $600B Question. The article examined the enormous investments flowing into AI infrastructure and the revenue necessary to economically justify that investment. The $600 billion figure represented an illustrative annual revenue requirement implied by infrastructure spending assumptions, rather than an observed industry loss. The underlying question was straightforward: Where would sufficient revenue come from to support the infrastructure being built? Two years later, that question remains relevant, but its implications extend beyond infrastructure providers and frontier model developers. It’s becoming a question for every company building AI-powered applications. In January 2026, Epoch AI published an analysis examining whether AI companies could become profitable. Using publicly reported information and financial assumptions, the researchers estimated that OpenAI’s offerings during the GPT-5 flagship period generated approximately $6 billion in revenue against $4 billion in inference compute expenditure. That suggested a gross margin of roughly 30% after inference compute costs. However, the researchers estimated that margins became substantially thinner after accounting for other operating expenditure, even before fully incorporating research and development costs. These were independent estimates, not audited company financial results. The analysis also covered a bundle of OpenAI products, not GPT-5 inference alone. Still, the broader lesson matters. Generating revenue from AI inference is not the same as generating sustainable profits from AI products. An AI business must support infrastructure, research, talent, distribution, reliability, and continued product development. Increasing revenue is essential, but so is understanding what it costs to generate that revenue. ## We Might Be Optimizing the Wrong Metrics Product teams have become exceptionally good at evaluating AI models. We compare accuracy, latency, reasoning capabilities, context windows, benchmark scores, and token prices. These measurements are valuable. But they don’t necessarily tell us whether an AI-powered workflow makes economic sense. Consider two hypothetical AI systems performing the same task. System A uses a relatively inexpensive model but requires multiple reasoning attempts, repeated retrieval operations, and additional validation steps. System B uses a more expensive model but completes the task reliably with fewer executions. Looking exclusively at token pricing might suggest that System A is more economical. Looking at the total cost of completing the task could lead to a different conclusion. This is supported by a 2025 research paper titled Economic Evaluation of LLMs, which argues that model selection should consider the economic consequences of errors, latency, and abstention alongside inference expenditure. The researchers demonstrated that more capable models can become economically preferable when mistakes carry meaningful costs. The findings were based on mathematical reasoning benchmarks, but the framework offers a useful way to think about enterprise AI. The cheapest inference isn’t necessarily the cheapest successful outcome. I believe this should fundamentally change how we evaluate AI product performance. Instead of measuring only cost per token or cost per request, product teams should increasingly measure: * **Cost per completed task:** Total computation and execution expenditure associated with delivering an outcome. * **Cost per successful task:** Total expenditure, including retries and failures, relative to successfully completed tasks. * **Value generated per task:** The measurable business benefit created by the completed workflow. * **Cost of errors:** The operational, financial, or regulatory consequences of incorrect outputs. * **Contribution margin per workflow:** Revenue attributable to the workflow minus the variable costs required to deliver it. The objective is not simply reducing inference expenditure. It’s maximizing the value generated by reliable AI execution. ## Healthcare AI Makes This Problem Particularly Interesting Consider a clinical intelligence platform. A physician or care management professional asks: “Which patients have potential documentation gaps, and what clinical evidence supports those findings?” It appears to be a straightforward question. But answering it accurately could require retrieving longitudinal patient records, examining clinical documentation, identifying relevant diagnoses, evaluating evidence, applying coding rules, and generating an explainable response. Now imagine executing similar workflows across tens of thousands of patients. What initially appears to be a conversational interface becomes a computationally intensive clinical intelligence system. But here’s the important distinction. Not every task in that workflow requires the same degree of AI reasoning. Retrieving a patient’s most recent encounter might require a structured database query. Identifying the latest documented HbA1c result could involve deterministic retrieval over normalized clinical information. Evaluating whether a diagnosis has adequate supporting documentation might require semantic interpretation and more sophisticated reasoning. Determining whether an HCC is valid under the applicable coding model also requires controlled reference logic, clinical evidence, and appropriate review. Using the same expensive frontier model for every step might be unnecessarily costly. However, using the cheapest possible model for every step would introduce a different problem. In healthcare, incorrect outputs can have consequences beyond software performance. An unsupported diagnosis could create compliance concerns. An incorrectly interpreted clinical record could generate misleading recommendations. An inaccurate quality measure assessment could affect reporting or operational decisions. This means healthcare AI cannot optimize inference expenditure independently of accuracy, clinical safety, traceability, and regulatory requirements. The economic objective becomes more specific: **Deliver the lowest sustainable cost per clinically accurate, evidence-grounded outcome.** That’s a substantially different problem from simply choosing the cheapest language model. ## From Model Selection to Intelligent Orchestration This brings us to what I believe will become an increasingly important architectural capability: intelligent orchestration. Today, many AI systems are designed around a relatively straightforward pattern. A user submits a request, relevant context is retrieved, and a language model generates an answer. More sophisticated systems introduce agents, tool calling, retrieval-augmented generation, and multi-step reasoning. But as these systems become more complex, we need to ask whether every request should follow the same computational pathway. A more economically efficient architecture would first understand the nature of the request. Can the answer be retrieved from validated structured data? Can a deterministic rule produce the required result? Does an existing, sufficiently current computation already contain the answer? Would a smaller specialized model be sufficient? Or does the request genuinely require more expensive frontier-model reasoning? The answers to these questions should influence how the system executes the workflow. This is not merely theoretical. Research presented at ICLR 2025, RouteLLM: Learning to Route LLMs from Preference Data, demonstrated that intelligent routing between stronger and weaker models could reduce inference expenditure by more than twofold in certain benchmark settings while preserving measured response quality. These savings are workload-dependent, and equivalent results should not be assumed in regulated clinical applications without validation. Nevertheless, the research supports a broader architectural direction. Rather than treating the language model as the default solution for every computational problem, AI systems can selectively allocate intelligence where it creates the most value. Structured retrieval, caching, deterministic execution, specialized models, and frontier reasoning each have a role. The challenge is orchestrating them intelligently while maintaining reliability. And this has implications beyond engineering. It affects product pricing, scalability, reliability, customer experience, and ultimately gross margins. Model orchestration is becoming a product strategy decision, not simply an infrastructure optimization. ## The Pricing Problem Nobody Can Ignore There’s another dimension worth discussing. AI agents are changing how software is consumed. Traditional SaaS pricing commonly revolves around seats, subscriptions, usage tiers, or access to functionality. But autonomous AI introduces a more complicated relationship between consumption and cost. Two customers might purchase identical subscriptions while generating dramatically different computational workloads. A user who executes a few simple tasks may be inexpensive to serve. Another user who delegates complex, long-running workflows may consume significantly more resources. If their revenue contribution remains similar, their margins can diverge. This doesn’t necessarily mean subscription pricing is obsolete. It means AI product companies need better mechanisms for connecting pricing, usage, and delivered value. We may increasingly see hybrid approaches combining subscriptions, usage allowances, consumption-based billing, and outcome-linked pricing. However, outcome-based pricing introduces its own challenge. If the computational cost of completing a task is unpredictable, pricing that task profitably becomes difficult. This is precisely why understanding workflow-level economics matters. Before deciding how customers should pay, companies need to understand what delivering a successful outcome actually costs. ## The Next Competitive Advantage I don’t believe the conclusion from this research is that AI is inherently unprofitable. Inference efficiency is improving rapidly. Hardware continues to advance. Models are becoming more capable. Competition is creating opportunities to deliver comparable performance at lower prices. And AI can generate substantial economic value by reducing operational effort, accelerating decisions, and enabling work that previously required significant human involvement. The opportunity remains enormous. But the economics cannot be an afterthought. For AI product leaders, the challenge is evolving from demonstrating what an AI system can do to demonstrating what it can do reliably, repeatedly, and sustainably. That requires product teams to understand not only model performance but also workload behavior, cost variability, customer value, and the economic consequences of errors. It requires engineering teams to build systems that use computation deliberately rather than indiscriminately. And it requires leadership teams to recognize that rapid adoption, impressive demonstrations, and increasing inference consumption are not necessarily indicators of sustainable business performance. Elon Musk’s statement about Grok Bot may have been about a particular product and its serving costs. But the underlying problem is much larger. As AI becomes capable of performing increasingly complex work, the cost of delivering that intelligence becomes an integral part of the product itself. The next competitive advantage in AI may not belong exclusively to the company with the smartest model. It may belong to the company that delivers the most reliable intelligence, creates the greatest measurable value, and does so with sustainable economics. And perhaps that’s the question AI product teams should be asking more often: > Are we building products that maximize intelligence, or products that maximize > the economic value of intelligence? ## Research and References 1. [Stanford HAI (2025) — Artificial Intelligence Index Report 2025. Research on declining inference prices and AI development economics.](https://hai.stanford.edu/ai-index/2025-ai-index-report/research-and-development) 2. [Stanford Digital Economy Lab (2026) — How Do AI Agents Spend Your Money? Analyzing and Predicting Token Consumption in Agentic Coding Tasks. Working paper on computational consumption across agentic software engineering workloads.](https://digitaleconomy.stanford.edu/publication/how-do-ai-agents-spend-your-money-analyzing-and-predicting-token-consumption-in-agentic-coding-tasks/) 3. [Sequoia Capital (2024) — David Cahn, AI’s $600B Question. Analysis of infrastructure spending and the revenue required to support the AI ecosystem.](https://sequoiacap.com/article/ais-600b-question/) 4. [Epoch AI (2026) — Can AI Companies Become Profitable? Lessons from GPT-5’s Economics. Independent estimates of model-serving revenue, inference expenditure, operating economics, and development costs.](https://epoch.ai/gradient-updates/can-ai-companies-become-profitable) 5. [Zellinger & Thomson (2025) — Economic Evaluation of LLMs. Research on evaluating AI systems using the financial consequences of inference, errors, latency, and abstention.](https://arxiv.org/abs/2507.03834) 6. [Ong et al. (ICLR 2025) — RouteLLM: Learning to Route LLMs from Preference Data. Research on optimizing inference expenditure through intelligent model routing.](https://proceedings.iclr.cc/paper_files/paper/2025/hash/5503a7c69d48a2f86fc00b3dc09de686-Abstract-Conference.html) 7. [TechCrunch (November 2, 2026) — Reporting on Elon Musk’s comments about Grok Bot’s serving costs and usage limitations.](https://techcrunch.com/2026/11/02/elon-musk-throttles-grok-bot-limits-due-to-unsustainably-high-costs/) #ArtificialIntelligence #AgenticAI #AIProducts #ProductStrategy #AIEconomics #HealthcareAI The post [The AI Profitability Paradox: When More Users Don’t Mean More Profits](https://mohammadjazim.blog/2026/11/06/ai-profitability-paradox-users-profits/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## I Built a Creator Campaign Control Plane: From Creator CSV to Recommendations, Economics, Outreach, and Campaign Briefs - Link: https://mohammadjazim.blog/2026/06/14/creator-campaign-control-plane-ai-campaign-decisions/ - Published: 2026-06-14T23:09:14+05:30 - Author: Mohammad Jazim Standard creator campaign workflows rely heavily on manual spreadsheets, which become inefficient as datasets scale. To solve this, a Creator Campaign Control Plane was developed to automate candidate evaluation using deterministic business rules combined with targeted artificial intelligence tools. The system processes creator datasets and campaign briefs to calculate budget economics, performance metrics, and candidate rankings. It then uses artificial intelligence agents to generate explanations, outreach emails, negotiation strategies, and campaign briefs. Initially built in Google Colab, the tool was deployed using Streamlit. Most creator campaign workflows still look like this: ```wp-block-code Creator spreadsheet↓Manual filtering↓Shortlist creators↓Estimate pricing↓Write outreach↓Negotiate↓Create campaign brief ``` This works when the creator list is small. But once the dataset grows, the process becomes messy. You are not just picking creators. You are making a campaign decision across category fit, location, language, pricing, follower base, creator tier, risk, budget, and expected performance. So I built a small MVP: ## Creator Campaign Control Plane The goal was not to build a generic chatbot. The goal was to build a workflow system that takes: ```wp-block-code Creator CSV + Campaign Brief ``` and produces: ```wp-block-code Ranked creatorsCampaign economicsBudget simulationsSelection explanationsOutreach draftsNegotiation strategyCreator campaign briefExecutive recommendation ``` The first version was built in Google Colab, then moved toward a Streamlit demo interface. --- ## The Use Case The campaign brief was: ```wp-block-code Brand type: Fashion + skincareCampaign: Diwali saleGoal: Drive awareness and conversions through creator-led video contentTarget market: Mumbai and DelhiPreferred creator location: MumbaiBudget: ₹15,000Deliverables: 4 weekly videosContent format: Video / ReelPreferred languages: Hindi, English, Hinglish ``` The creator file included fields like: ```wp-block-code full_nameinstagram_handlecategorycategory_groupbiocontent_languagecitystatecountryfollower_basefollower_bandcreator_tierreel_rate_avgvideo_rate_avgstatic_post_rate_avgemailphone_numberwhatsapp_possible ``` This made the project feel more like a real campaign planning tool than a toy recommender. --- ## The Main Architecture The workflow was built around a meta-controller. ```wp-block-code Creator CSV↓Data Intake Agent↓Schema Validation Agent↓Normalization Agent↓Planner Agent↓Category Fit Agent↓Location Fit Agent↓Language Fit Agent↓Pricing Agent↓Budget Fit Agent↓Campaign Economics Agent↓Creator Tier Agent↓Risk / Quality Proxy Agent↓Data Quality Agent↓Conflict Resolver Agent↓Final Recommendation Agent↓Budget Simulation Agent↓AI Explanation Agent↓AI Outreach Email Agent↓AI Negotiation Agent↓AI Campaign Brief Agent↓AI Final Recommendation Agent ``` The project combines deterministic business logic with AI-generated action outputs. The notebook includes the full flow: CSV upload, campaign brief, scoring agents, campaign economics, budget simulation, AI explanation, email draft generation, negotiation plan, campaign brief, and final recommendation generation. The key design principle was: > Rules calculate. AI explains and activates. I did not want the LLM to calculate CPM, CPC, CPA, or CPI. Those are deterministic calculations. The AI layer is used for reasoning, explanation, outreach, negotiation, and campaign narrative. --- ## Step 1: Upload Creator CSV The first step was uploading the creator database into Colab. The system reads the file and converts it into a pandas dataframe. The business logic here is simple: ```wp-block-code Accept the creator databaseStandardize itPrepare it for analysis ``` The Data Intake Agent standardizes column names so that the rest of the workflow can depend on a predictable schema. Example: ```wp-block-code "Creator Name" → creator_name"Video Rate Avg" → video_rate_avg"Follower Base" → follower_base ``` This is important because creator data usually comes from CRMs, Airtable, internal spreadsheets, or agency databases. --- ## Step 2: Define the Campaign Brief The campaign brief works like the operating instruction for the control plane. For this MVP, the brief included: ```wp-block-code brand_namecampaign_goaltarget_categoriestarget_category_groupstarget_citiespreferred_citycountrybudgetrequired_videoscontent_formatcampaign_typepreferred_languagesassumed_view_rateassumed_ctrassumed_conversion_rateassumed_install_rate ``` Example: ```wp-block-code brand_brief = { "brand_name": "Fashion + Skincare Diwali Sale Brand", "campaign_goal": "Drive Diwali sale awareness and conversions through creator-led video content", "target_categories": ["fashion", "beauty", "skincare", "cosmetics", "lifestyle"], "target_cities": ["mumbai", "delhi"], "preferred_city": "mumbai", "budget": 15000, "required_videos": 4, "content_format": "video", "campaign_type": "sale_conversion"} ``` This made every recommendation campaign-specific. The system was not asking: ```wp-block-code Who are the best creators? ``` It was asking: ```wp-block-code Who are the best creators for this specific Diwali fashion/skincare campaign, in this market, with this budget, and this content requirement? ``` --- ## Step 3: Schema Validation Agent The Schema Validation Agent checks whether the uploaded creator file has the required fields. Required fields included: ```wp-block-code full_nameinstagram_handlecategorycategory_groupcitycountryfollower_basecreator_tierreel_rate_avgvideo_rate_avg ``` If the file has the right fields, it is marked as ready. If not, the system can flag missing columns before running recommendations. This prevents the system from pretending to know things it does not know. --- ## Step 4: Normalization Agent The Normalization Agent cleans text and numeric values. Examples: ```wp-block-code "Mumbai" → "mumbai""₹15,000" → 15000"50K" → 50000"1.2M" → 1200000 ``` This step is basic but critical. Without normalization, location matching, pricing calculations, follower-based estimates, and category scoring can break. --- ## Step 5: Planner Agent The Planner Agent creates the execution plan. For this campaign, the planner routed the workflow through: ```wp-block-code data intakeschema validationnormalizationcategory fitlocation fitlanguage fitpricingbudget fitcampaign economicscreator tier scoringrisk proxydata quality scoringconflict resolutionfinal recommendation ``` This is where the project starts to feel like a control plane rather than a spreadsheet. The planner defines what needs to happen, and the meta-controller executes the plan. --- ## Step 6: Category Fit Agent The Category Fit Agent scores each creator based on campaign relevance. For this use case, the strongest categories were: ```wp-block-code beautyskincarecosmeticsfashionclothingaccessorieslifestyle ``` The business logic was: ```wp-block-code Beauty / skincare / cosmetics → strongest fitFashion / clothing / accessories → strong fitLifestyle → useful supporting fitUnrelated categories → weak fit ``` This ensured that creators were not selected just because they had followers. They had to fit the campaign. --- ## Step 7: Location Fit Agent The campaign preferred Mumbai creators and also considered Delhi. The Location Fit Agent scored creators like this: ```wp-block-code Mumbai creator → highest scoreDelhi creator → strong scoreIndia-based creator → moderate scoreOther location → lower score ``` This matters because campaign relevance is not only about content category. For a Diwali sale campaign, geography can influence audience relevance, language, shipping, cultural fit, and brand positioning. --- ## Step 8: Language Fit Agent The campaign preferred: ```wp-block-code HindiEnglishHinglish ``` The Language Fit Agent checked the creator’s content language and scored whether the creator could naturally communicate the campaign. This matters a lot in Indian consumer campaigns because the same campaign can perform very differently depending on language and tone. --- ## Step 9: Pricing Agent The Pricing Agent selected the best available content rate. Since the campaign required video content, the system prioritized: ```wp-block-code video_rate_avgthen reel_rate_avgthen static_post_rate_avg ``` Then it calculated: ```wp-block-code selected_video_raterequired_videostotal_campaign_costprice_per_video_target ``` For this campaign: ```wp-block-code Total budget = ₹15,000Required videos = 4Target price per video = ₹3,750 ``` This converts creator pricing into a campaign-level cost estimate. --- ## Step 10: Budget Fit Agent The Budget Fit Agent checked whether each creator fit the campaign budget. The logic was: ```wp-block-code Within budget → strong scoreSlightly above budget → possibleModerately above budget → cautionToo expensive → weak fit ``` This is important because a creator can be creatively perfect but commercially unrealistic. A good campaign recommendation has to balance both. --- ## Step 11: Campaign Economics Agent This was one of the most important parts of the project. The Campaign Economics Agent calculated: ```wp-block-code estimated impressionsestimated clicksestimated conversionsestimated installsCPMCPCCPACPI ``` The formulas were: ```wp-block-code estimated_impressions = follower_base × assumed_view_rate × required_videosestimated_clicks = estimated_impressions × assumed_ctrestimated_conversions = estimated_clicks × assumed_conversion_rateestimated_installs = estimated_clicks × assumed_install_rateCPM = total_campaign_cost / estimated_impressions × 1000CPC = total_campaign_cost / estimated_clicksCPA = total_campaign_cost / estimated_conversionsCPI = total_campaign_cost / estimated_installs ``` This changed the system from a creator shortlist tool into a decision engine. Instead of asking: ```wp-block-code Who has the most followers? ``` the system asks: ```wp-block-code Who gives the best expected campaign efficiency? ``` --- ## Step 12: Creator Tier Agent The Creator Tier Agent scored creators based on tier and follower base. For a ₹15,000 campaign, nano and micro creators often make more sense than macro or mega creators. The logic was: ```wp-block-code Nano creator → strong fit for low-budget campaignMicro creator → strong fitMid-tier creator → possible depending on pricingMacro creator → may be expensiveMega creator → likely not budget-aligned ``` This reflects a real creator economy insight: > Bigger creators are not always better for every campaign. --- ## Step 13: Risk / Quality Proxy Agent The Risk / Quality Proxy Agent looked for operational issues in the creator profile. It flagged things like: ```wp-block-code missing Instagram handlemissing Instagram URLmissing biomissing citymissing categorymissing pricingmissing follower basehigh rate for low follower base ``` This is not a full fake-follower detection system, but it provides a useful first- pass quality signal. It helps decide whether a creator should be recommended, reviewed, or skipped. --- ## Step 14: Data Quality Agent The Data Quality Agent scored creator profile completeness. It checked whether each creator had important fields: ```wp-block-code nameInstagram handleInstagram URLcategorycategory groupcitycountryfollower basecreator tierselected rate ``` This was useful because incomplete creator data may still be usable, but it should not be treated with the same confidence as a complete profile. --- ## Step 15: Conflict Resolver Agent The Conflict Resolver Agent identified trade-offs between agents. Examples: ```wp-block-code Strong category fit but weak location fitStrong category fit but poor budget fitBudget-friendly but weak category fitHigh proxy risk detectedStrong fit across category, location, and budget ``` This was one of the more interesting parts of the project. A simple recommendation system just adds scores. The conflict resolver adds business judgment. It recognizes that a creator can be strong in one dimension and weak in another. --- ## Step 16: Final Recommendation Agent The Final Recommendation Agent created the final ranking. The final score combined: ```wp-block-code category fitlocation fitlanguage fitbudget fiteconomics scorecreator tier scoredata quality scorerisk scoreconflict adjustment ``` The system then assigned each creator a status: ```wp-block-code RecommendedConsider with cautionNot Recommended ``` The final table included: ```wp-block-code creator nameInstagram handlecategorycityfollower baseselected ratetotal campaign costbudget fitestimated impressionsestimated clicksestimated conversionsestimated installsCPMCPCCPACPIfinal scorerecommendation statusrisk flagsconflicts ``` This gave both the recommendation and the reasoning behind the recommendation. --- ## Step 17: Budget Simulation Agent The Budget Simulation Agent reran the same campaign logic across different budgets. Example budgets: ```wp-block-code ₹10,000₹15,000₹25,000₹50,000₹100,000 ``` For each budget, the system returned: ```wp-block-code top creatorselected ratetotal campaign costestimated impressionsestimated clicksestimated conversionsestimated installsCPMCPCCPACPIfinal scorerecommendation status ``` This made the project much more useful. A campaign manager can ask: ```wp-block-code What changes if the budget increases?What if the budget decreases?Does the recommended creator change?At what budget does the campaign become more efficient? ``` That turns the workflow into a decision simulator. --- ## Step 18: AI Creator Explanation Agent After the deterministic agents created structured evidence, I added AI agents. The first was the AI Creator Explanation Agent. It took: ```wp-block-code campaign brieftop creator evidencescoreseconomicsrisksconflicts ``` and generated business-friendly explanations. For each creator, it explained: ```wp-block-code why they fit the campaignbudget fitexpected campaign economicsrisks or trade-offsfinal recommendation ``` This is useful because stakeholders do not always want to inspect every score manually. They want a clear explanation. --- ## Step 19: AI Outreach Email Agent The AI Outreach Email Agent generated personalized email drafts for the top creators. Each email included: ```wp-block-code subject linegreetingwhy the creator is a fitcampaign askdeliverablessoft budget mentioncall to action ``` The system does not automatically send emails. The safer MVP workflow is: ```wp-block-code Generate draftHuman reviewsHuman sends ``` That keeps the agent useful without making it risky. --- ## Step 20: AI Negotiation Agent The AI Negotiation Agent generated negotiation strategies based on pricing and budget fit. If a creator was within budget, it suggested confirmation steps. If a creator was above budget, it suggested options like: ```wp-block-code bundle discountreduced deliverablesperformance-linked upsidealternative content package ``` This moved the project beyond recommendation. It started supporting the actual campaign operations workflow. --- ## Step 21: AI Campaign Brief Agent The AI Campaign Brief Agent generated a creator-facing campaign brief. It included: ```wp-block-code campaign namecampaign objectivetarget audiencedeliverablescontent anglesvideo structurecaption guidanceCTAdos and don'tsapproval workflowsuggested hashtags ``` This answered the next practical question: ```wp-block-code Once we select creators, what should they create? ``` --- ## Step 22: AI Final Recommendation Agent The AI Final Recommendation Agent generated an executive summary. It summarized: ```wp-block-code recommended creatorswhy they were selectedexpected reach and economicsbudget recommendationrisksnext steps ``` This made the output more useful for founders, campaign managers, marketing teams, and agency operators. --- ## Step 23: Streamlit Demo Layer After the Colab prototype worked, I connected the project to Streamlit. The architecture became: ```wp-block-code Colab = testing and development notebookGitHub = code repositoryStreamlit = live product demo ``` The project was split into: ```wp-block-code app.py → Streamlit interfaceagents.py → backend agents and business logicrequirements.txtREADME.md ``` Streamlit handles: ```wp-block-code CSV uploadcampaign brief formrun analysis buttonranked recommendation tablebudget simulation tableAI output generationdownload buttons ``` The important connection is: ```wp-block-code from agents import meta_controllerranked, recommendation = meta_controller(raw_df, brand_brief) ``` Streamlit does not call Colab. Streamlit runs the same backend logic directly from the project files. --- ## Step 24: Removing Credentials One important cleanup step was removing credentials from the code. The original prototype had a hardcoded API key during testing. That should never be shared, committed, or deployed. The correct approach is: ```wp-block-code Use environment variables in ColabUse st.secrets in StreamlitKeep credentials out of GitHub ``` For Colab: ```wp-block-code from getpass import getpassimport osos.environ["GROQ_API_KEY"] = getpass("Enter your Groq API key: ") ``` For Streamlit: ```wp-block-code api_key = st.secrets["GROQ_API_KEY"] ``` This keeps the project safe and shareable. --- ## What Makes This Different From a Chatbot A chatbot gives an answer. This system runs a workflow. A chatbot would do: ```wp-block-code Ask: Which creators should I pick?Answer: Here are some creators. ``` This system does: ```wp-block-code Upload creator CSVValidate schemaNormalize dataScore category fitScore location fitScore language fitSelect pricingCheck budgetCalculate CPM / CPC / CPA / CPIScore creator tierFlag riskResolve conflictsRank creatorsSimulate budgetsExplain recommendationsDraft outreach emailsSuggest negotiation strategyGenerate campaign briefWrite executive recommendation ``` That is not a chatbot. That is a campaign operating workflow. --- ## What I Learned The biggest learning was that AI should not do everything. For this use case: ```wp-block-code Pandas is better for cleaning and calculations.Business rules are better for pricing and scoring.Deterministic formulas are better for CPM, CPC, CPA, and CPI.AI is better for explanations, outreach, negotiation, and briefs.The controller is what connects everything into one workflow. ``` The model matters. But the system around the model matters more. I would describe the MVP as: > A Creator Campaign Control Plane that converts a creator database and campaign > brief into ranked creator recommendations, campaign economics, budget simulations, > outreach drafts, negotiation strategy, and creator-facing campaign briefs. It started as a Colab notebook. Then it became a Streamlit demo. Architecturally, it shows how creator economy workflows can move beyond spreadsheets into coordinated agent systems. The most interesting part was not generating text. The interesting part was combining structured data, deterministic scoring, campaign economics, agent orchestration, and AI-generated action outputs into one end-to- end workflow. The post [I Built a Creator Campaign Control Plane: From Creator CSV to Recommendations, Economics, Outreach, and Campaign Briefs](https://mohammadjazim.blog/2026/06/14/creator-campaign-control-plane-ai-campaign-decisions/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## Running Voicebox Backend End-to-End on Google Colab with GPU-Based Audio Transcription - Link: https://mohammadjazim.blog/2026/06/14/voicebox-backend-google-colab-gpu/ - Published: 2026-06-14T03:38:53+05:30 - Author: Mohammad Jazim The Voicebox backend was successfully deployed and tested end-to-end within a Google Colab environment using a GPU runtime. After setting up the repository, installing required dependencies, and starting the FastAPI server with Uvicorn, health checks verified that the API was operational and detecting GPU acceleration. Subsequent tests confirmed the backend could receive uploaded audio files and return speech-to-text transcriptions via its API. This successful validation demonstrates that Voicebox can function as a cloud-hosted voice AI backend, supporting potential integrations into healthcare dictation, customer service, sales automation, and field data workflows. This article explains how we tested the **Voicebox backend** end-to-end inside ** Google Colab**. The goal was to verify whether the backend API could run in a cloud notebook environment, use a GPU, accept an uploaded audio file, and process it through the `/transcribe` endpoint. The full execution took around **13 minutes**, including repository setup, dependency installation, backend debugging, GPU activation, API health checks, and audio transcription testing. This was not a test of the full desktop app. It was specifically a backend/API validation. --- ## What Is Voicebox? Voicebox is a voice AI application/backend that exposes API endpoints for speech and audio workflows. In this test, we focused on the backend routes such as: ```wp-block-code /docs/profiles/health/transcribe/generate/speak ``` The backend is built using FastAPI and can be started with Uvicorn. Once running, it can receive audio files through HTTP requests and return transcription results. In simple terms: ```wp-block-code Audio file → Voicebox backend → Transcription response ``` --- ## Objective of the Test The main objective was to prove that Voicebox can run in Google Colab as a backend service. We wanted to validate: ```wp-block-code Clone repo↓Install dependencies↓Start backend server↓Confirm API health↓Enable GPU↓Upload MP3 audio↓Call /transcribe endpoint↓Receive transcription response ``` This is useful because it proves that Voicebox does not need to run only as a local desktop app. Its backend can also be tested in a cloud environment. --- ## Environment Used The test was performed in **Google Colab**. The runtime was changed from CPU to GPU, and the selected GPU was: ```wp-block-code Tesla T4 ``` After switching to GPU, the backend logs confirmed: ```wp-block-code GPU: CUDA (Tesla T4) ``` This means the backend was able to detect and use GPU acceleration. --- ## Step 1: Clone the Voicebox Repository The first step was to clone the Voicebox GitHub repository into Colab: ```wp-block-code !git clone https://github.com/jamiepine/voicebox.git%cd /content/voicebox ``` This downloaded the backend code into the Colab environment. --- ## Step 2: Install Required Dependencies Some dependencies were already covered by the project requirements, but during execution, we discovered additional missing packages. The first missing package was: ```wp-block-code fastmcp ``` The backend failed with: ```wp-block-code ModuleNotFoundError: No module named 'fastmcp' ``` We fixed it using: ```wp-block-code !pip install fastmcp ``` Later, the backend failed again because another dependency was missing: ```wp-block-code pedalboard ``` The error was: ```wp-block-code ModuleNotFoundError: No module named 'pedalboard' ``` We fixed it using: ```wp-block-code !pip install pedalboard ``` So the dependency fixes were: ```wp-block-code !pip install fastmcp!pip install pedalboard ``` --- ## Step 3: Start the Voicebox Backend The correct FastAPI app entry point was: ```wp-block-code APP_MODULE = "backend.app:app" ``` The backend was started using Uvicorn: ```wp-block-code server = subprocess.Popen( [ "python", "-m", "uvicorn", APP_MODULE, "--host", "0.0.0.0", "--port", str(PORT), "--log-level", "info", ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1,) ``` The server ran on: ```wp-block-code http://127.0.0.1:17493 ``` The successful startup log showed: ```wp-block-code Voicebox v0.5.0 starting upBackend: PYTORCHGPU: CUDA (Tesla T4)Application startup completeUvicorn running on http://0.0.0.0:17493Backend server is running. ``` --- ## Step 4: Validate Backend API Health After starting the backend, we tested the main API endpoints: ```wp-block-code for endpoint in ["/docs", "/profiles", "/health", "/"]: r = requests.get(BASE_URL + endpoint, timeout=10) print(endpoint, r.status_code) print(r.text[:500]) ``` The successful results were: ```wp-block-code /docs 200/profiles 200/health 200/ 200 ``` The `/health` response confirmed that the backend was healthy: ```wp-block-code { "status": "healthy", "backend_type": "pytorch", "backend_variant": "gpu", "gpu_available": true} ``` This confirmed that the API server was live and ready to receive requests. --- ## Step 5: Upload Audio File We uploaded an MP3 file recorded using an online voice recorder: ```wp-block-code Record (online-voice-recorder.com).mp3 ``` The file was uploaded through Colab using: ```wp-block-code from google.colab import filesuploaded = files.upload()audio_path = next(iter(uploaded.keys())) ``` The file type was: ```wp-block-code audio/mpeg ``` --- ## Step 6: Call the `/transcribe` Endpoint Initially, the transcription request failed with status `422` because the file was sent using the wrong field name: ```wp-block-code files_payload = { "audio": (audio_path, f)} ``` The backend expected the field name to be: ```wp-block-code file ``` So the corrected request was: ```wp-block-code with open(audio_path, "rb") as f: files_payload = { "file": (audio_path, f, "audio/mpeg") } data = { "model": "whisper-turbo" } r = requests.post( f"{BASE_URL}/transcribe", files=files_payload, data=data, timeout=300, ) ``` The expected successful response is: ```wp-block-code Status: 200 ``` And the JSON response should contain the transcription text, typically something like: ```wp-block-code { "text": "Transcribed speech appears here."} ``` The exact response format depends on how the Voicebox backend implements the `/transcribe` route. --- ## Final Working Flow The final working flow required two main cells. ### Cell 1: Start Backend ```wp-block-code %cd /content/voiceboximport subprocessimport timeimport socketPORT = 17493APP_MODULE = "backend.app:app"try: server.terminate() print("Stopping previous server instance...")except Exception: passserver = subprocess.Popen( [ "python", "-m", "uvicorn", APP_MODULE, "--host", "0.0.0.0", "--port", str(PORT), "--log-level", "info", ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1,)print(f"Starting server using {APP_MODULE}...")start = time.time()while time.time() - start < 90: if server.poll() is not None: print("Server exited. Logs:") for _ in range(120): line = server.stdout.readline() if not line: break print(line, end="") break line = server.stdout.readline() if line: print(line, end="") try: with socket.create_connection(("127.0.0.1", PORT), timeout=1): print("\nBackend server is running.") print("Server running in background. NOW RUN THE TRANSCRIPTION CELL.") break except OSError: pass ``` ### Cell 2: Upload and Transcribe Audio ```wp-block-code from google.colab import filesimport requestsimport jsonBASE_URL = "http://127.0.0.1:17493"uploaded = files.upload()audio_path = next(iter(uploaded.keys()))with open(audio_path, "rb") as f: files_payload = { "file": (audio_path, f, "audio/mpeg") } data = { "model": "whisper-turbo" } r = requests.post( f"{BASE_URL}/transcribe", files=files_payload, data=data, timeout=300, )print("Status:", r.status_code)try: print(json.dumps(r.json(), indent=2)[:4000])except Exception: print(r.text[:4000]) ``` --- ## Issues Faced and Fixes ### Issue 1: Backend did not start Error: ```wp-block-code ModuleNotFoundError: No module named 'fastmcp' ``` Fix: ```wp-block-code !pip install fastmcp ``` ### Issue 2: Another missing dependency Error: ```wp-block-code ModuleNotFoundError: No module named 'pedalboard' ``` Fix: ```wp-block-code !pip install pedalboard ``` ### Issue 3: Wrong upload field Error: ```wp-block-code { "detail": [ { "loc": ["body", "file"], "msg": "Field required" } ]} ``` Fix: ```wp-block-code files_payload = { "file": (audio_path, f, "audio/mpeg")} ``` ### Issue 4: Connection refused Error: ```wp-block-code Connection refused ``` Cause: The backend server was not running. Fix: Start the backend cell first, wait for: ```wp-block-code Backend server is running. ``` Then run the transcription cell. --- ## What We Achieved End-to-End By the end of the test, we achieved a working backend execution flow: ```wp-block-code Google Colab GPU runtime↓Voicebox repository cloned↓Missing dependencies installed↓FastAPI backend started↓Health endpoints verified↓GPU detected successfully↓Audio file uploaded↓/transcribe endpoint called ``` The most important achievement was that we proved Voicebox can run as a **cloud- hosted voice backend** in Colab, using GPU acceleration. This validates the backend layer of a voice AI product. --- ## Real-World Business Use Cases ### 1. Healthcare Dictation Doctors can record consultation notes, and the backend can convert speech to text. Example workflow: ```wp-block-code Doctor speaks consultation↓Voicebox transcribes audio↓AI converts transcript into SOAP note↓Doctor reviews↓Note is saved to EMR ``` Business value: ```wp-block-code Less typingFaster documentationBetter doctor productivityStructured medical records ``` --- ### 2. Call Center Automation Customer support calls can be uploaded and transcribed. Example output: ```wp-block-code Full transcriptCustomer issueAgent responseSentimentEscalation flagSummary ``` Business value: ```wp-block-code Automated QAFaster ticket summariesBetter customer insightsReduced manual review ``` --- ### 3. Sales Meeting Intelligence Sales calls or meeting recordings can be transcribed and summarized. Example workflow: ```wp-block-code Meeting audio↓Transcript↓Pain points extracted↓Next steps generated↓CRM updated ``` Business value: ```wp-block-code Better sales follow-upReduced admin workImproved CRM hygieneHigher conversion visibility ``` --- ### 4. Voice-Based Internal Automation Employees can speak commands instead of typing them. Example: ```wp-block-code “Create a follow-up task for Raj tomorrow at 4 PM.” ``` The system can convert that into: ```wp-block-code Task: Follow upAssignee: RajDue: Tomorrow 4 PM ``` Business value: ```wp-block-code Hands-free workflowsFaster operationsUseful for mobile teamsBetter productivity ``` --- ### 5. Field Data Collection Field workers can record voice notes from visits, inspections, or surveys. Example workflow: ```wp-block-code Field worker records observation↓Voicebox transcribes audio↓AI extracts structured fields↓Data saved to dashboard ``` Business value: ```wp-block-code Useful in healthcare campsInsurance surveysLogisticsRural operationsCompliance reporting ``` --- ## What This Test Does Not Cover This test only validates the backend. It does not test: ```wp-block-code Desktop app UITauri app behaviorGlobal hotkeysAuto-pasteSystem trayLocal macOS integrationsProduction deploymentAuthenticationUser managementBillingLong-term storage ``` Those would be the next steps for a production-grade application. --- ## Production Architecture Possibility A production version could look like this: ```wp-block-code Frontend / Mobile App / Desktop App↓Voicebox Backend API↓GPU inference server↓Transcription engine↓LLM summarization layer↓Database↓Dashboard / EMR / CRM / Helpdesk ``` For a healthcare product, the architecture could become: ```wp-block-code Doctor audio↓Voicebox transcription↓Medical summarization model↓SOAP note generation↓Doctor approval↓EMR save ``` --- ## Conclusion This end-to-end test successfully validated that the Voicebox backend can run in Google Colab with GPU support and expose working API endpoints. The execution took around **13 minutes**, mainly because of dependency installation, debugging, server startup, GPU setup, and audio testing. The main outcome is that Voicebox can be treated not only as a desktop voice app, but also as a potential **voice AI backend service**. This opens up practical business opportunities in healthcare, call centers, sales automation, field operations, and internal productivity tools. In simple terms, we proved this: ```wp-block-code Voice recording → Cloud backend → Speech-to-text API → Business workflow foundation ``` The post [Running Voicebox Backend End-to-End on Google Colab with GPU-Based Audio Transcription](https://mohammadjazim.blog/2026/06/14/voicebox-backend-google-colab-gpu/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## 2026 Guide to AI Video Generation: Which Tool Works Best for Your Business? - Link: https://mohammadjazim.blog/2026/06/08/ai-video-generators-2026-best-tools/ - Published: 2026-06-08T01:25:10+05:30 - Author: Mohammad Jazim Gone are the days when creating a high-quality video required a camera crew, studio lighting, and a video editor. In 2026, AI video generation has evolved from experimental tech into a practical business tool. The challenge isn’t whether AI can generate good video — it’s figuring out which tool works best for your specific needs. I’ve evaluated seven of the most capable AI video generators available today, tested their real-world performance, and mapped them to concrete business use cases. Whether you’re a content marketer, startup founder, educator, or social media creator, this guide will help you pick the right tool for your workflow — and show you how to actually integrate it into your daily operations. --- ## The Seven Tools at a Glance | Tool | Best For | Key Strength | Starting Price | | **Slop Club** | Memes, social video, community-driven content | Uncensored creation & social remixing | Free (then $5/mo) | | **Veo** (Google) | Cinematic shots, brand storytelling | Physics-aware realism & native audio | $0.03–$0.60/sec | | **Sora** (OpenAI) | Concept testing, high-quality ideation | Photorealistic output & natural language control | Included in ChatGPT Plus ($20/mo) | | **Dream Machine** (Luma) | Cinematic shorts, visual art | Image-to-video & mood-driven motion | $9.99–$30/mo | | **Runway Gen-4** | Creative editing, professional workflows | World consistency & granular control | $12–$76/mo | | **Kling AI** | Action scenes, product visuals | Natural character motion & physics | $6.99–$127.99/mo | | **HeyGen** | Marketing, UGC, localization | Photorealistic avatars & 175+ languages | $24–$120+/mo | Now, let’s dive deep into each one. --- ## 1. Slop Club: The Fun, Uncensored Playground **Best for:** Memes, experimental social video, and creators who value community- driven experimentation. Slop Club stands out for one simple reason: it’s built for fun. Unlike polished enterprise tools, Slop Club embraces the chaotic, creative energy of internet culture. It’s an AI video platform that allows users to generate and remix videos from text prompts — sometimes called the “TikTok for AI videos.” **What makes it different:** * **Curated models:** The platform uses models like Wan 2.2, GPT-image, and Seedream, giving users access to multiple generation engines. * **Social remixing:** The “Slop Jam” game and community features make content creation inherently collaborative — you’re not creating in a void. * **Uncensored nature:** Unlike many competitors, Slop Club doesn’t heavily restrict what you can generate. This openness is a core part of its appeal for experimental creators. * **Earn while creating:** Built on Solana blockchain, users can earn SCLUB tokens when they create or remix content. **The trade-offs:** Slop Club isn’t built for cinematic realism or professional- grade output. If you need polished brand videos or precise control, this isn’t your tool. It’s for rapid iteration, meme generation, and social-first content where “ vibe” matters more than fidelity. **Pricing:** Free initially, then $5/month with refill options. **Business use cases:** * Social media managers testing viral concepts quickly * Community managers engaging audiences with user-generated remixes * Experimental marketers exploring low-fidelity, high-engagement formats --- ## 2. Google Veo: The Cinematic Realist **Best for:** Storytelling, cinematic shots, and any use case where physics and realism matter. Google’s Veo family has quickly become the gold standard for physics-aware, cinematic video generation. The current recommended model is Veo 3.1, as both Veo 2 and Veo 3 are being retired by June 30, 2026[](https://picsart.com/blog/veo-models-comparison/). **What makes it different:** * **Built-in audio generation:** Veo 3 and 3.1 generate synchronized dialogue, sound effects, and ambient music alongside the video — eliminating post-production audio work[](https://picsart.com/blog/veo-models-comparison/)[](https://www.powtoon.com/blog/veo-3-vs-sora/). * **Cinematic controls:** You can specify camera movements like dolly, pan, tracking, and low-angle shots, and Veo executes them with professional precision[](https://kr.cyberlink.com/blog/the-top-video-editors/3807/google-gemini-video-generator#best_alt). * **Reference image support:** Veo 3.1 accepts up to three reference images to guide output style and composition[](https://deepwiki.com/google-gemini/cookbook/5.3-video-generation-with-veo). * **Video extension:** Generate and extend videos up to 141 seconds total — significantly longer than most competitors[](https://deepwiki.com/google-gemini/cookbook/5.3-video-generation-with-veo). * **4K output capability:** Available in preview for premium tiers[](https://picsart.com/blog/veo-models-comparison/). **Performance highlights:** In stress tests for ad production, Google Veo 3.1 won for ad-ready output, prompt control, and native audio quality. It excels at water, fabric, and particle effects, making it the strongest choice for physically complex scenes[](https://www.lovart.ai/blog/how-to-choose-ai-video-model?srsltid=AfmBOor2oOmX_E8cXm2qPMG-JTPYLRHZnJNiQmy3i8tYCB7fSoCbQI-0). **Pricing:** Pay-per-second model ranging from $0.03 per second (Lite tier, 720p, video only) to $0.60 per second (Standard tier, 4K with audio). For a 10-second 4K clip with audio, that’s roughly $6[](https://picsart.com/blog/veo-models-comparison/). **How to access:** Veo is available through Gemini Advanced subscription, Vertex AI for developers, and integrated into YouTube Shorts Dream Screen[](https://aiwiki.ai/wiki/veo_2). **Business use cases:** * **Premium brand campaigns:** When you need one hero video for a product launch * **Ad creative testing:** For production-ready output that can go directly into paid media * **Product demonstrations:** Where accurate physics and motion matter (e.g., showing how a product behaves) * **Short-form storytelling:** YouTube Shorts, Instagram Reels, TikTok — Veo is optimized for these formats[](https://kr.cyberlink.com/blog/the-top-video-editors/3807/google-gemini-video-generator#best_alt) --- ## 3. OpenAI Sora: The High-Quality Ideation Engine **Best for:** Concept testing, high-quality creative exploration, and scenes requiring complex physics. OpenAI’s Sora has been one of the most anticipated AI video models since its announcement. Sora 2, released in September 2025, brought major improvements in video length, audio synchronization, and character cameos[](https://wavespeed.ai/blog/posts/openai-sora-2-complete-guide-2026/). **Important update:** As of April 26, 2026, the standalone Sora product has been discontinued, but the model is rolling out at [sora.com](https://sora.com/), and the API remains available until September 2026[](https://openai.com/index/sora-is-here/?trk=article-ssr-frontend-pulse_little-text-block). **What makes it different:** * **Physics accuracy:** Sora 2 remains the benchmark for physics-aware, photorealistic output. It excels at fluid dynamics, lighting, and gravity — complex interactions that other models often get wrong[](https://investor.wedbush.com/wedbush/article/abnewswire-2026-1-20-wan-26-vs-sora-2-vs-kling-26-the-2026-showdown). * **Synchronized audio generation:** Like Veo, Sora 2 now generates dialogue, ambient sound, and music alongside video[](https://wavespeed.ai/blog/posts/openai-sora-2-complete-guide-2026/). * **Character cameos:** With OpenAI’s $1 billion Disney partnership, you can generate videos featuring licensed Disney characters in custom scenarios[](https://wavespeed.ai/blog/posts/openai-sora-2-complete-guide-2026/). * **Extended length:** Up to 25 seconds per generation — longer than most competitors [](https://wavespeed.ai/blog/posts/openai-sora-2-complete-guide-2026/). * **1080p standard output:** Full HD with professional broadcast-ready quality[](https://wavespeed.ai/blog/posts/openai-sora-2-complete-guide-2026/). **The trade-offs:** Sora is premium-priced and access has historically been limited. The API is being phased out, so availability will shift through 2026. It also lacks the extensive editing tooling that platforms like Runway provide[](https://www.lovart.ai/blog/how-to-choose-ai-video-model?srsltid=AfmBOor2oOmX_E8cXm2qPMG-JTPYLRHZnJNiQmy3i8tYCB7fSoCbQI-0). **Pricing:** Included with ChatGPT Plus ($20/month) for limited usage (up to 50 videos at 480p resolution per month). Pro tier offers 10x more usage at higher resolutions [](https://openai.com/index/sora-is-here/?trk=article-ssr-frontend-pulse_little-text-block). **Business use cases:** * **Concept visualization:** Before investing in a full production, test your vision * **High-end B-roll:** For cinematic sequences where physics must be perfect * **Entertainment content:** Short-form narrative scenes, especially with character consistency * **Agency pitching:** Create impressive concept videos for client approvals --- ## 4. Luma Dream Machine: The Cinematic Speedster **Best for:** Fast cinematic iteration, visual art, and projects where character consistency across scenes matters. Luma’s Dream Machine sits in a sweet spot between speed and quality. It’s faster than Kling but more cinematic than Pika — making it a favorite for agency campaign work[](https://melies.co/kling-vs-pika-vs-luma). **What makes it different:** * **Ray3 Annotations (Scribbles):** This feature lets you visually “draw” motion paths directly on your image, giving the AI much stronger directional cues than text alone[](https://sites.duke.edu/ddmc/2026/02/17/real-human-support-in-an-ai-world-my-experience-with-luma-labs/#respond). * **Character consistency from reference images:** Luma excels at maintaining character identity across multiple scenes — stronger than Kling or Pika in this trio[](https://melies.co/kling-vs-pika-vs-luma). * **Luma Agents framework:** Runs multi-step creative workflows (brand identity, storyboards) that competitors don’t match. This is why Publicis, Mazda, and Dentsu use Luma for campaign work[](https://melies.co/kling-vs-pika-vs-luma). * **HiFi upscaling:** Generate in draft mode to test concepts, then upscale the exact output you like to 1080p without regenerating from scratch[](https://sites.duke.edu/ddmc/2026/02/17/real-human-support-in-an-ai-world-my-experience-with-luma-labs/#respond). * **Image-to-video and text-to-video:** Generate 5-10 second clips at 1080p. **Performance notes:** Dream Machine delivers strong realism and natural motion when it works correctly — physics usually behave reasonably, which matters for product demos and customer-facing content[](https://www.goenhance.ai/zh/blog/luma-ai-review). Generation time for a 5-10 second clip is about 1-2 minutes[](https://www.goenhance.ai/zh/blog/luma-ai-review). **The trade-offs:** No native audio generation — you’ll need to add sound in post- production. Complex multi-character scenes can produce artifacts[](https://www.goenhance.ai/zh/blog/luma-ai-review). **Pricing:** Starts at $9.99/month, with Plus at $30/month[](https://www.techjockey.com/us/detail/dream-machine#pricing) [](https://melies.co/kling-vs-pika-vs-luma). **Business use cases:** * **Brand campaigns:** Multiple cohesive scenes with consistent characters * **Storyboard visualization:** Turn written storyboards into animated sequences * **Product photography animation:** Bring static product images to life with subtle motion * **Fast iteration for agencies:** Test multiple creative directions without long render times --- ## 5. Runway Gen-4: The Precision Tool for Professionals **Best for:** Creative editing, advanced workflows, and projects where you need granular control over every element. Runway has long been the professional’s choice for AI video, and Gen-4 continues that legacy. Its breakthrough feature is “world consistency” — maintaining character, object, and style consistency across multiple scenes, even under different lighting conditions[](https://baike.baidu.com/item/Runway%20Gen-4/65550597). **What makes it different:** * **World consistency:** Create coherent worlds where the same character appears in multiple shots looking identical — handled better than any competitor[](https://milvus.io/ai-quick-reference/how-does-sora-compare-to-runway-gen4). * **Motion brush:** Target specific areas of an image for movement control — draw exactly where you want motion to happen[](https://milvus.io/ai-quick-reference/how-does-sora-compare-to-runway-gen4). * **Inpainting & outpainting:** Full video editing primitives that let you modify existing videos without regenerating from scratch[](https://milvus.io/ai-quick-reference/how-does-sora-compare-to-runway-gen4). * **Gen-4 Turbo:** Lightning-fast generation — 10-second videos in approximately 30 seconds (up to 5x faster than previous models) while maintaining quality[](https://wavespeed.ai/blog/posts/introducing-runway-gen4-turbo-on-wavespeedai/#introducing-runway-gen4-turbo-on-wavespeedai). * **Generative VFX:** Built-in visual effects tools that go beyond basic generation [](https://baike.baidu.com/item/Runway%20Gen-4/65550597). * **API-first architecture:** Substantially larger API surface than competitors, enabling sophisticated automated workflows[](https://milvus.io/ai-quick-reference/how-does-sora-compare-to-runway-gen4). **Performance strengths:** Excellent for product demonstrations with sharp close- ups and realistic lighting. Maintains flawless frame-to-frame consistency with natural object permanence[](https://coverr.co/ai/models/runway-gen-4). **The trade-offs:** While physics is good for simple scenarios, it degrades with complex interactions. The learning curve is steeper than simpler tools — you need to learn the control interfaces[](https://milvus.io/ai-quick-reference/how-does-sora-compare-to-runway-gen4). Not ideal for long-form narrative coherence beyond 4-10 second clips. **Pricing:** Standard plan at $12/month, Unlimited at $76/month[](https://milvus.io/ai-quick-reference/how-does-sora-compare-to-runway-gen4). **Business use cases:** * **Professional video production:** Where control matters more than out-of-the- box results * **Fashion and e-commerce:** Turn product photography into dynamic video showcases with realistic fabric movement[](https://wavespeed.ai/blog/posts/introducing-runway-gen4-turbo-on-wavespeedai/#introducing-runway-gen4-turbo-on-wavespeedai) * **Marketing campaigns:** Add subtle motion to static ads to make them scroll- stopping[](https://wavespeed.ai/blog/posts/introducing-runway-gen4-turbo-on-wavespeedai/#introducing-runway-gen4-turbo-on-wavespeedai) * **Content creation at scale:** Use Turbo mode to iterate rapidly on social content * **Rapid prototyping for filmmakers:** Visualize scenes before committing to full production[](https://wavespeed.ai/blog/posts/introducing-runway-gen4-turbo-on-wavespeedai/#introducing-runway-gen4-turbo-on-wavespeedai) --- ## 6. Kling AI: The Motion and Character Expert **Best for:** Action scenes, product visuals, and any video where humans are moving, talking, or acting. Kling AI, developed by Kuaishou Technology, has become the global leader in natural character motion. It hit $240 million in annualized revenue just 19 months after launch — a testament to its quality. **What makes it different:** * **Motion quality leadership:** Kling is widely considered the “motion king” — character movement looks natural and physics make sense. * **Micro-expressions:** Captures subtle facial nuances — raised eyebrows, slight smirks — that other models smooth out[](https://investor.wedbush.com/wedbush/article/abnewswire-2026-1-20-wan-26-vs-sora-2-vs-kling-26-the-2026-showdown). * **Motion Capture feature:** Transfer your real movements onto AI-generated characters. Record yourself acting a scene and map it onto any character. * **Multi-shot generation (Kling 3.0):** Generate up to 6 different shots in a single prompt loop with shot-reverse-shot transitions and automatic scene coherence [](https://miao.wondershare.cn/video-editor-review/kling-ai-review.html). * **Omni native audio:** Generates voiceover, lip-synced dialogue, sound effects, and ambient music in 5 languages with regional accents[](https://miao.wondershare.cn/video-editor-review/kling-ai-review.html). * **Extended duration:** Up to 15 seconds per generation at HD resolution — longer than most competitors[](https://melies.co/kling-vs-pika-vs-luma). * **4K HDR support:** Native 1080p to 4K HDR output at 30-60 FPS[](https://miao.wondershare.cn/video-editor-review/kling-ai-review.html). * **Subject consistency 3.0:** Upload reference images to lock in character appearance, voice, and style across every generation[](https://miao.wondershare.cn/video-editor-review/kling-ai-review.html). **The trade-offs:** Kling is slower to iterate than Pika or Luma — per-clip cost is medium to high, and top-end fidelity sits below Veo 3.1 and Runway Gen-4[](https://melies.co/kling-vs-pika-vs-luma). **Pricing:** Ranges from $6.99 to $127.99 per month depending on tier and usage. **Business use cases:** * **Character-driven narratives:** Any video where human performance is central * **Dialogue scenes:** Where voice ID matters across multiple shots[](https://melies.co/kling-vs-pika-vs-luma) * **Product demos:** Where you need to show a person interacting with a product * **Short-form entertainment:** Narrative content longer than 8 seconds with consistent characters * **Marketing with people:** UGC-style content that requires believable human motion --- ## 7. HeyGen: The Avatar and Localization Powerhouse **Best for:** Marketing videos, UGC content, multilingual localization, and talking- head productions at scale. HeyGen is the leader in AI avatar video generation. It converts scripts, text, or uploaded footage into talking-head videos using photorealistic avatars and synthetic voices — all without a camera or actors[](https://www.lovart.ai/zh/blog/heygen-review). **What makes it different:** * **Avatar V (April 2026):** The most advanced avatar model yet. Record one 15- second clip, and you get full upper-body movement, multi-look generation (different outfits/settings), multi-angle consistency, and long-form stability without drift [](https://www.heygen.com/blog/heygen-april-2026-release). * **Seedance 2.0 integration:** HeyGen is the first platform integrating Seedance 2.0 with identity-verified human faces — your real Digital Twin gets cinematic motion and dynamic camera work[](https://www.heygen.com/blog/heygen-april-2026-release). * **Video Agent:** A “creative agent” workflow that writes a script, picks visuals, assigns an avatar and voice, and outputs a finished clip — automating the entire script-to-video pipeline[](https://www.lovart.ai/zh/blog/heygen-review). * **Massive language support:** 175+ languages and dialects with real-time translation while maintaining natural lip sync[](https://wavespeed.ai/blog/posts/heygen-vs-synthesia-comparison-2026/?utm_campaign=openai-mythos&utm_medium=referral&utm_source=digest.bipiai.com). * **Digital Twins:** Create a personalized avatar from your own photo and voice sample for authentic personal branding at scale[](https://wavespeed.ai/blog/posts/heygen-vs-synthesia-comparison-2026/?utm_campaign=openai-mythos&utm_medium=referral&utm_source=digest.bipiai.com). * **Extensive integrations:** Now available across Android, with workflows that make video native to your operations. **Performance highlights:** In head-to-head comparisons, HeyGen has a slight edge over Synthesia in processing speed for complex scenes with multiple avatars. It can produce videos up to 30 minutes long with custom digital twins and 175+ languages. **The trade-offs:** Avatar quality, while extremely good, isn’t a full substitute for on-location filming with multi-camera storytelling. Some emotional nuance can feel slightly uncanny at times[](https://www.lovart.ai/zh/blog/heygen-review). **Pricing:** Free tier available (limited). Paid plans range from $24 to $120+ per month depending on features and usage. **Business use cases:** * **Marketing at scale:** Generate hundreds of video ads quickly * **Multilingual localization:** Produce the same message in 175+ languages without reshoots * **UGC-style content:** Create authentic-looking user-generated content without filming * **Internal communications:** Employee training, announcements, and updates at scale * **Sales enablement:** Personalized video outreach with your sales team’s avatars * **E-commerce product explainers:** Fast, low-cost product demos --- ## How to Integrate These Tools into Your Daily Operations Now that you understand each tool’s strengths, let’s talk about practical integration. AI video generation isn’t just about which tool is “best” — it’s about weaving these capabilities into your existing workflows. ### For Marketers | Use Case | Recommended Tool | Integration Strategy | | Daily social media content | Slop Club or Kling | Batch generate 50-100 clips weekly; schedule via Buffer/Hootsuite | | Product launch hero video | Veo or Runway Gen-4 | Use it as a creative agency — brief, generate, refine, publish | | Multilingual ad campaigns | HeyGen | Create one master script; generate in 10+ languages simultaneously | | A/B testing ad creatives | Dream Machine | Generate 20+ variants; run performance tests before committing budget | **Pro tip:** Start with free tiers to validate concepts before scaling. Most platforms offer free generation with watermarks or limitations — perfect for internal testing and client pitching. ### For Startups and Founders | Use Case | Recommended Tool | Integration Strategy | | Explainer videos | HeyGen Video Agent | Input your product brief; get a finished video in minutes | | Pitch deck visuals | Dream Machine | Animate storyboards from your pitch deck | | User testimonials | HeyGen (Digital Twin) | Create an avatar that represents your brand spokesperson | | Product demos | Kling or Veo | Generate demonstration videos from product images | **Pro tip:** Use AI video for your landing page hero section. It’s dramatically cheaper than professional production and easier to iterate based on conversion data. ### For Content Creators | Use Case | Recommended Tool | Integration Strategy | | Daily shorts/reels | Slop Club or Dream Machine | Create content that matches trending audio and formats | | Long-form B-roll | Veo or Sora | Generate cinematic cutaways for talking-head videos | | Character-driven content | Kling | Maintain consistent characters across an entire series | | Studio-quality avatars | HeyGen | Replace on-camera appearances with your Digital Twin | **Pro tip:** Use Dream Machine’s draft mode to test 10-20 variations of a concept before committing credits to high-quality generation. The HiFi upscale feature lets you regenerate the exact draft you like at full quality[](https://sites.duke.edu/ddmc/2026/02/17/real-human-support-in-an-ai-world-my-experience-with-luma-labs/#respond). ### For Educators and Trainers | Use Case | Recommended Tool | Integration Strategy | | Training videos | HeyGen | Create an avatar instructor; update content without reshoots | | Scenario-based learning | Dream Machine | Generate multiple scenarios from a single storyboard | | Multilingual training | HeyGen | One script, 175+ languages | | Educational animations | Runway Gen-4 | Animate diagrams and illustrations | **Pro tip:** Luma offers an Education Program specifically for academic institutions [](https://sites.duke.edu/ddmc/2026/02/17/real-human-support-in-an-ai-world-my-experience-with-luma-labs/#respond). --- ## Practical Integration Frameworks ### The “Generate First, Refine Second” Workflow Most AI video tools can’t produce a perfect output on the first try. Here’s the workflow that works: 1. **Concept (15 min):** Write a detailed prompt or prepare reference images 2. **Draft generation (5-10 min):** Use free/draft modes to generate 5-10 variants 3. **Selection (10 min):** Pick the 2-3 most promising outputs 4. **Refinement (variable):** Use the specific tool’s controls to iterate on those 5. **Post-production (if needed):** Add audio, captions, or transitions Total time: 30-60 minutes for a production-ready short video. ### The “Multi-Tool Pipeline” No single tool excels at everything. Sophisticated creators use a pipeline: * **Storyboard:** Use Dream Machine’s Agents or generate from an LLM * **Base generation:** Veo or Sora for high-quality base clips * **Editing/refinement:** Runway Gen-4 for inpainting and precise motion control * **Avatar/narration:** HeyGen for talking-head segments * **Audio:** Use Veo’s native audio or add in post-production This approach yields professional results that outperform any single tool. --- ## Making Your Final Decision Here’s the simplest way to choose: | If you need… | Choose… | | High-quality, ad-ready videos with audio | **Veo** | | Character-driven stories with natural motion | **Kling** | | Granular control and professional editing | **Runway Gen-4** | | Fast iteration on cinematic visuals | **Dream Machine** | | Scalable talking-head videos in many languages | **HeyGen** | | Experimental, community-driven social content | **Slop Club** | | Photorealistic concept testing and ideation | **Sora** | **The bottom line:** AI video generation is no longer a futuristic gimmick. It’s a practical, production-ready capability that can save your business thousands of dollars and countless hours. The right tool for you depends entirely on what you’re trying to create and how much control you need. Start with free tiers. Test each tool on your actual use case — not the marketing demos. And remember: even the best AI video tool requires good prompting and iteration. The magic isn’t in pushing one button; it’s in building a workflow that combines AI generation with your creative direction. Happy creating. The post [2026 Guide to AI Video Generation: Which Tool Works Best for Your Business?](https://mohammadjazim.blog/2026/06/08/ai-video-generators-2026-best-tools/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## How Solo Founders Can Use AI to Build a Subscription App in a Weekend - Link: https://mohammadjazim.blog/2026/06/08/ai-solo-founders-build-saas-mvp-faster/ - Published: 2026-06-08T00:23:15+05:30 - Author: Mohammad Jazim A few years ago, building a subscription software product required a team. You needed a frontend developer, backend developer, designer, DevOps support, payment integration, email setup, authentication, database design, and weeks of coordination before the first real user could try the product. That equation has changed. AI coding agents, open-source starter kits, and modern SaaS infrastructure have compressed the MVP cycle dramatically. A solo founder can now build, launch, test, and charge for a focused product in days instead of months. The opportunity is not “get rich overnight.” The real opportunity is much more practical: build faster, validate earlier, and spend less money before learning whether the market actually wants your product. One useful example is an AI-powered fitness subscription app. Not because fitness apps are new. Because fitness apps reveal an important truth about software: people do not pay for features. They pay for progress. ## The Product Idea The product is an AI fitness coach called Summer Body Coach. It helps users create workout plans, log meals, build streaks, and receive personalized coaching based on their actual behavior. The app does not need to be complicated in version one. The MVP only needs to answer one question: Can this product help a user feel more consistent after seven days? If the answer is yes, it has a chance to become a subscription business. ## Why This App Can Work Most fitness apps fail because they are static. They ask users for a goal, generate a plan, and then expect perfect behavior. Real users do not behave that way. They miss workouts. They eat outside the plan.They lose motivation.They restart repeatedly. A better product adjusts with them. If a user completes 80% of their workouts, the plan can become slightly harder. If they complete only 40%, the app can reduce difficulty and protect the habit. That adaptive loop is where AI becomes useful. The product is not just a workout tracker. It is a feedback system. ## MVP Feature Set The first version should stay focused. Do not build a full fitness platform. Build the smallest product that can create a habit. ### MVP Features 1. Onboarding quiz 2. AI-generated 7-day workout plan 3. Meal photo logging 4. Daily check-in message 5. Streak tracking 6. Progress dashboard 7. AI coach chat 8. Stripe subscription with free trial Each feature supports one core behavior: get the user to come back tomorrow. That is the product. ## Recommended Tech Stack Start with web, not mobile. A web app is faster to ship, easier to update, easier to connect to Stripe, and simpler to deploy. A mobile app can come later once the product has real users and usage data. Frontend: Next.js 14 + TypeScript UI: Tailwind CSS + shadcn/uiDatabase/Auth: SupabasePayments: StripeEmails: ResendHosting: VercelAI Layer: Kimi K2.6 / OpenAI-compatible API The goal is not to use trendy tools. The goal is to remove friction. Every tool in the stack should help the founder move from idea to paid validation faster. ## Use Existing Projects as Reference The fastest way to build with AI is not to ask it to create everything from scratch. Instead, give the AI strong reference material. Use open-source projects for common product patterns such as authentication, Stripe billing, dashboards, workout tracking, and calorie logging. ### Useful Reference Categories * SaaS starter kit * Stripe subscription boilerplate * Supabase authentication example * Workout logging app * Exercise database * AI calorie tracker * Progress dashboard template This matters because most MVPs do not need original infrastructure. They need original positioning. Authentication is not the business. Billing is not the business.Dashboard layout is not the business. The business is the outcome the user wants. ## Main AI Build Prompt A strong prompt should describe the product like a product manager, not just like a developer. The AI needs to understand the user, the business model, the feature set, and the technical stack. ``` You are a senior product engineer and AI startup builder.We are building an AI-native fitness SaaS called Summer Body Coach.The product helps users:- create personalized workout plans- log meals- estimate calories from food photos- build daily streaks- receive personalized coaching- adapt workout difficulty based on completion dataUse this stack:- Next.js 14- TypeScript- Tailwind CSS- shadcn/ui- Supabase- Stripe- Resend- Vercel- OpenAI-compatible AI APIBuild the complete MVP:1. Supabase database schema2. Next.js App Router structure3. Authentication flow4. Stripe subscription flow with 7-day trial5. Onboarding quiz6. AI workout generation endpoint7. Meal photo upload flow8. Daily check-in logic9. Streak system10. User dashboard11. AI coach chat endpointFor every component:- write complete TypeScript code- include error handling- explain where the file should be placed- include testable logic- avoid placeholder code where possible ``` The prompt is important because vague instructions create generic products. Specific instructions create usable systems. ## Database Schema The database is the product’s memory. For an AI coaching product, this matters more than usual. The AI cannot personalize anything unless the app stores meaningful user behavior. A clean starting schema could look like this: ``` create table profiles ( id uuid references auth.users primary key, goal text not null, height_cm int, weight_kg decimal, activity_level text, equipment text[], weekly_days int, session_minutes int, created_at timestamp default now());create table workout_plans ( id uuid default gen_random_uuid() primary key, user_id uuid references profiles(id), plan jsonb not null, week_start date not null, created_at timestamp default now());create table workout_logs ( id uuid default gen_random_uuid() primary key, user_id uuid references profiles(id), plan_id uuid references workout_plans(id), workout_date date not null, completed boolean default false, completed_at timestamp);create table meal_logs ( id uuid default gen_random_uuid() primary key, user_id uuid references profiles(id), photo_url text, ai_analysis jsonb, logged_at timestamp default now());create table streaks ( user_id uuid references profiles(id) primary key, current_streak int default 0, longest_streak int default 0, last_active_date date);create table subscriptions ( user_id uuid references profiles(id) primary key, stripe_customer_id text, stripe_subscription_id text, status text, trial_ends_at timestamp, current_period_end timestamp); ``` This schema gives the app enough context to personalize workouts, measure consistency, and manage subscriptions. ## AI Coach API Route The AI coach should not behave like a generic chatbot. It should respond based on the user’s profile, workouts, meals, and streak data. ``` import OpenAI from "openai";const client = new OpenAI({ apiKey: process.env.MOONSHOT_API_KEY, baseURL: "https://api.moonshot.ai/v1",});export async function POST(req: Request) { try { const { profile, workouts, meals, streak, message } = await req.json(); if (!profile || !message) { return Response.json( { error: "Missing required profile or message" }, { status: 400 } ); } const completion = await client.chat.completions.create({ model: "kimi-k2-0711-preview", messages: [ { role: "system", content: `You are Summer Body Coach, a motivational but realistic AI fitness coach.Rules:- Give safe, practical fitness guidance.- Never provide medical diagnosis.- Keep responses under 150 words.- Reference the user's actual data.- Prioritize consistency over perfection.- If the user missed workouts, reduce guilt and simplify the next step.- If the user is consistent, encourage progression. `, }, { role: "user", content: JSON.stringify({ profile, workouts, meals, streak, message, }), }, ], }); return Response.json({ reply: completion.choices[0]?.message?.content ?? "", }); } catch (error) { return Response.json( { error: "Failed to generate coach response" }, { status: 500 } ); }} ``` This route can live at: ``` app/api/coach/route.ts ``` The key is that the AI receives context. Without context, it gives motivational noise. With context, it becomes a product experience. ## Workout Adaptation Logic The app should adjust difficulty based on completion. This is the core loop. ``` type Difficulty = "easy" | "moderate" | "hard";export function calculateNextDifficulty( completedWorkouts: number, totalWorkouts: number): Difficulty { if (totalWorkouts === 0) { return "easy"; } const completionRate = completedWorkouts / totalWorkouts; if (completionRate >= 0.85) { return "hard"; } if (completionRate >= 0.55) { return "moderate"; } return "easy";} ``` This simple function creates personalization. A user who is succeeding gets challenged. A user who is struggling gets a plan they can actually follow. That is how the product protects retention. ## Streak Logic Streaks give the user a reason to return. The logic should be simple and reliable. ``` export function updateStreak( lastActiveDate: string | null, currentStreak: number, longestStreak: number, today: string) { if (!lastActiveDate) { return { currentStreak: 1, longestStreak: Math.max(1, longestStreak), lastActiveDate: today, }; } const last = new Date(lastActiveDate); const current = new Date(today); const diffInDays = Math.floor( (current.getTime() - last.getTime()) / (1000 * 60 * 60 * 24) ); if (diffInDays === 0) { return { currentStreak, longestStreak, lastActiveDate, }; } if (diffInDays === 1) { const newStreak = currentStreak + 1; return { currentStreak: newStreak, longestStreak: Math.max(newStreak, longestStreak), lastActiveDate: today, }; } return { currentStreak: 1, longestStreak, lastActiveDate: today, };} ``` This is not just a gamification feature. It is a retention mechanic. A user with a seven-day streak is more likely to return than a user with an empty dashboard. ## Stripe Subscription Route For a habit-based product, a 7-day trial can work well because the user has time to experience progress before paying. ``` import Stripe from "stripe";const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);export async function POST(req: Request) { try { const { userId, email } = await req.json(); if (!userId || !email) { return Response.json( { error: "Missing userId or email" }, { status: 400 } ); } const session = await stripe.checkout.sessions.create({ customer_email: email, mode: "subscription", payment_method_types: ["card"], line_items: [ { price: process.env.STRIPE_PRICE_ID!, quantity: 1, }, ], subscription_data: { trial_period_days: 7, metadata: { userId, }, }, success_url: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard?success=true`, cancel_url: `${process.env.NEXT_PUBLIC_APP_URL}/pricing`, }); return Response.json({ url: session.url }); } catch (error) { return Response.json( { error: "Failed to create checkout session" }, { status: 500 } ); }} ``` This route can live at: ``` app/api/stripe/checkout/route.ts ``` The trial should not be treated as a payment trick. It should be treated as an activation window. The product has seven days to prove value. ## AI Skill File A useful AI product needs consistent behavior. Instead of rewriting the same instructions in every prompt, create a reusable skill file. ``` # Summer Body Coach SkillYou are Summer Body Coach, a motivational but realistic AI fitness coach.Your job:- help users build consistent fitness habits- create simple workout plans- estimate calories and macros from meal data- encourage daily check-ins- adapt weekly plans based on completion- protect motivation when users miss daysRules:- never give medical diagnosis- never shame the user- keep advice practical- keep daily check-ins under 120 words- reference the user's actual data- simplify the plan if the user missed 2 or more days- increase intensity if the user completed 85% or more of workouts- prioritize consistency over perfectionTone:- direct- encouraging- specific- calm- non-judgmental ``` This helps the AI feel like part of the product instead of a generic assistant. Brand consistency matters. So does behavioral consistency. ## The Business Model The simplest business model is a monthly subscription. Price: $9.99/month Trial: 7 daysTarget user: People who want simple fitness accountabilityCore value: Personalized daily coaching and adaptive plans Revenue examples: 100 users x $9.99 = $999/month 500 users x $9.99 = $4,995/month1,000 users x $9.99 = $9,990/month3,000 users x $9.99 = $29,970/month This does not mean every app will reach those numbers. Most will not. But the math shows why solo SaaS is attractive. A small number of paying users can create meaningful revenue when the product is focused and costs are controlled. ## Estimated Monthly Costs A lean MVP might have costs like this: Supabase: $25/month Vercel: $20/monthResend: $20/monthAI API usage: $100-$300/monthStripe fees: variable The biggest cost is usually not infrastructure. It is wasted time building the wrong thing. That is why fast validation matters. ## Getting the First 100 Users The first users should come from visibility, not ads. A founder can show the product being built in public: ### Content Ideas * “I used AI to generate my workout plan” * “Here is how the app adjusts when I miss a workout” * “I logged my lunch with a photo” * “Day 4 of testing my own fitness app” * “Users told me the plan was too hard, so I changed the logic” * “Building a fitness SaaS from scratch with AI” The best early channels are: TikTok Instagram ReelsRedditProduct HuntX/TwitterIndie hacker communitiesFitness communities The goal is not to pretend the product is perfect. The goal is to invite people into the process. Early users who give feedback often become more invested because they feel like they helped shape the product. ## What AI Can and Cannot Do AI can help with: * writing code * debugging errors * creating database schemas * generating API routes * building UI components * writing onboarding flows * creating test cases * summarizing user feedback * improving prompts But AI cannot fully replace product judgment. The founder still has to answer: Who is this for? Why would they use it every day?What result do they want?What makes them come back?What makes them pay?What makes them cancel? That is where the business is won. The code matters. But the user insight matters more. ## The Real Playbook The modern indie SaaS playbook looks like this: 1. Pick a painful recurring problem. 2. Choose a narrow audience. 3. Build a small MVP with AI assistance. 4. Use existing tools instead of reinventing infrastructure. 5. Launch publicly. 6. Watch what users actually do. 7. Improve the habit loop. 8. Add payment only around clear value. 9. Keep the product simple. 10. Repeat fast. The advantage is not that AI guarantees success. It does not. The advantage is that AI lowers the cost of learning. A founder can now test more ideas, ship faster, and reach the truth earlier. ## Final Takeaway The next generation of solo founders will not win because they write every line of code themselves. They will win because they understand users better, move faster, and use AI to remove everything that slows down validation. An AI fitness coach is just one example. The same approach can work for education, productivity, personal finance, career coaching, language learning, health habits, creator tools, and niche B2B workflows. The formula is simple: Clear problem. Small product.Fast build.Public launch.Real feedback.Paid validation. That is the new indie software advantage. Not hype. Leverage. The post [How Solo Founders Can Use AI to Build a Subscription App in a Weekend](https://mohammadjazim.blog/2026/06/08/ai-solo-founders-build-saas-mvp-faster/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## Power of Asking, Goal Setting, and Massive Action - Link: https://mohammadjazim.blog/2026/06/07/power-of-asking/ - Published: 2026-06-07T20:59:10+05:30 - Author: Mohammad Jazim How to Get What You Want in Life: The Power of Asking, Goal Setting, and Massive Action Most people want more from life. More success. More money.More happiness.More confidence.More freedom.More meaning. But very few people stop long enough to ask the most important question: **What do I actually want?** That question sounds simple, but it is where transformation begins. Many people work hard for years without clearly asking for anything specific. They show up, stay busy, do what is expected, and hope life eventually rewards them. But success rarely comes from vague effort. It comes from clear asking, intelligent goal setting, personal growth, and massive action. If you want to know how to get what you want in life, the first lesson is this: **You must learn the art of asking.** --- ## The First Step to Getting What You Want Is Asking Asking is not weakness. It is not begging. It is not wishful thinking. Asking is the beginning of receiving. Every goal, dream, business, relationship, career move, and personal breakthrough starts with some form of asking. You ask yourself: “What do I want?” You ask life: “What is possible for me?” You ask others: “Can you help me?” You ask your future: “What must I become to deserve this?” Most people never receive what they truly want because they never clearly ask for it. They say things like: “I want to be successful.” “I want to make more money.”“I want a better life.”“I want to be happier.” But those are not clear asks. They are vague wishes. A powerful ask is specific. Instead of saying, “I want more money,” say: “I want to increase my income by 30% in the next 12 months by improving my skills, creating more value, and pursuing better opportunities.” Instead of saying, “I want to be healthier,” say: “I want to lose 10 kilograms, exercise four times a week, sleep seven hours a night, and improve my energy within six months.” Clarity changes everything. --- ## Ask With Intelligence: Be Clear About What You Want One of the biggest mistakes people make in goal setting is that they ask without intelligence. They mumble their desires. They say they want a better life, but they never define what “better” means. Intelligent asking means being specific. You must ask: How much? By when?What kind?What size?What result?What standard?What habit?What direction? The clearer your goal becomes, the stronger its pull becomes. A vague goal has weak energy. A specific goal becomes a magnet. For example, “I want to grow my business” is vague. A stronger version would be: “I want to grow my business from ₹10 lakh to ₹25 lakh in annual revenue within 18 months by improving customer acquisition, increasing retention, and launching two new service packages.” Now the mind has something to work with. You can build a plan around that. You can measure it. You can review progress. You can adjust. That is the power of asking with intelligence. --- ## Ask With Faith: Believe Before You See the Result Intelligence gives your goal structure. Faith gives your goal energy. To get what you want in life, you need both. You must plan like an adult but believe like a child. Adults often become too skeptical. They talk themselves out of possibility before they even begin. They say: “That will never work.” “I’m too old.”“I don’t have the right background.”“I tried before.”“People like me don’t get those opportunities.” But childlike belief is different. A child imagines freely. A child expects possibility. A child does not immediately build a list of reasons why something cannot happen. This does not mean being foolish. It means allowing belief to support your effort. The strongest formula is: **Make practical plans like an adult, but believe in them with the openness of a child.** When clarity and belief come together, action becomes easier. --- ## Receiving Is Not the Main Problem Many people think receiving is the hard part. But often, the real issue is not receiving. The real issue is failing to ask clearly, consistently, and boldly. Life has more opportunity than most people are prepared to receive. Success is not in short supply. Wealth, wisdom, relationships, ideas, and growth are not limited to a lucky few. But people approach the ocean of opportunity with a teaspoon. They ask too small. They think too small.They act too small.They prepare too little. They give up too quickly. If life is an ocean, do not bring a teaspoon. Bring a bucket. That means expanding your goals, your discipline, your courage, your skills, and your capacity to receive. --- ## Goal Setting Is Not Enough Without Massive Action Asking is the beginning. But action is what turns desire into reality. A written goal without action is only a dream. A plan without execution is only an idea. To change your life, you must take massive action. Not occasional action. Not lazy action.Not “I’ll try it once or twice” action. Massive action. If you are going to make calls, make many calls. If you are going to build relationships, meet many people.If you are going to create content, create consistently.If you are going to learn a skill, practice deeply.If you are going to improve your health, commit daily. Small action can create momentum, but massive action creates transformation. Most people fail not because the idea was bad, but because their action was too weak. They try something for 30 days and quit. They post three times and stop. They reach out to five people and assume networking does not work. They apply for two roles and decide the market is impossible. The problem is not always the strategy. Sometimes the problem is the volume of action. --- ## Do Not Let Learning Replace Doing Learning is important. But learning without action becomes a trap. Many people keep consuming books, videos, podcasts, courses, and seminars because learning feels productive. But if learning never turns into behavior, it becomes a sophisticated form of procrastination. Knowledge alone does not change your life. Applied knowledge does. Do not let your learning lead only to information. Let your learning lead to action. Read the book, then apply one principle. Watch the video, then change one habit. Attend the workshop, then execute one idea.Study the market, then launch the offer. Learn the skill, then use it in public. A good idea with heavy action is more powerful than a thousand ideas with no execution. --- ## Personal Development: Success Is Something You Attract One of the most powerful ideas in personal development is this: **Success is something you attract by the person you become.** You do not merely chase success. You grow into the kind of person who can hold it. That means the major question is not only: “What am I getting?” The better question is: “What am I becoming?” At work, do not only ask, “How much am I being paid?” Ask: “What skills am I developing?” “What discipline am I building?”“What kind of reputation am I creating?”“What value am I learning to provide?”“What kind of person is this environment shaping me into?” Income matters. Results matter. Achievement matters. But who you become matters more, because your character, skills, mindset, and habits determine what you can attract and sustain. Happiness is not only found in what you get. It is found in what you become. --- ## The Four Seasons of Life Life moves in seasons. There are winters, springs, summers The post [Power of Asking, Goal Setting, and Massive Action](https://mohammadjazim.blog/2026/06/07/power-of-asking/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## From Search API to Research Agents: A Practical Blueprint for Building with Exa Agent and Exa MCP - Link: https://mohammadjazim.blog/2026/06/07/building-ai-research-agents-exa-agent-mcp/ - Published: 2026-06-07T01:54:19+05:30 - Author: Mohammad Jazim ## If you are starting with Exa’s new Agent and MCP products, the first thing to understand is this: **they solve two different but related problems**. **Exa Agent** is for high-compute research, list-building, enrichment, and structured outputs. It can take a broad query like “Find AI infrastructure companies hiring founding designers” and return a researched, schema-driven table with companies, roles, locations, compensation, evidence, and exclusions. **Exa MCP** is for connecting Exa’s search tools directly into AI coding assistants and desktop AI clients such as Cursor, Claude Desktop, Claude Code, VS Code, Codex, Windsurf, Gemini CLI, and others. It gives these assistants tools like `web_search_exa`,` web_fetch_exa`, and advanced web search. Together, they form a useful stack for anyone building AI products that need reliable web research, enrichment, and agentic workflows. --- ## What we tested We tested Exa Agent with a real research-style prompt: ``` Find AI infrastructure companies hiring founding designers ``` The run completed successfully and cost **$0.16**. The output found: ``` 9 plausible active AI infrastructure or AI/developer-infrastructure companies3 excluded or closed cases ``` The active results included companies such as: | Company | Role | Fit | | TensorZero | Founding MTS — Design Engineering | Strong AI infrastructure fit | | Capy | Founding Design Engineer | Strong developer/agent infrastructure fit | | Tempo | Founding Product Designer | AI-assisted developer tooling fit | | Jinba | Founding Design Engineer | AI-native workflow/agent platform | | Weave | Founding Design Engineer | AI engineering productivity tooling | | kapa.ai | Founding Designer | AI assistant platform for technical content | The output was not just a list. It included role fit, location, compensation, and evidence. That is important because this type of task is not simple search. It requires discovery, filtering, judgment, and enrichment. That is where Agent becomes useful. --- ## Why Exa Agent ? Traditional search APIs are good when you know what you are looking for. For example: ``` Search for the latest TensorZero jobs ``` But Agent is better when the task is open-ended: ``` Find AI infrastructure companies currently hiring founding designers, founding product designers, or founding design engineers.Include only active roles.Exclude closed, removed, expired, or non-design roles.Verify using company careers pages or original job posts where possible.Return structured JSON. ``` This is not one search. It is a workflow. The agent needs to: 1. Understand the criteria. 2. Search across multiple sources. 3. Identify candidate companies. 4. Check if the role is actually active. 5. Exclude false positives. 6. Normalize the result into a structured format. 7. Provide evidence. That is the product value: **turning messy web research into structured, usable data**. --- ## The technical agent-making process A good Agent workflow has four parts: ### 1. Query The query should describe the job clearly. Weak prompt: ``` Find AI infra companies hiring designers ``` Better prompt: ``` Find AI infrastructure companies currently hiring founding designers, founding product designers, or founding design engineers.Include only roles that appear active as of June 7, 2026.Prioritize US, Canada, and remote roles.Exclude closed, removed, expired, or non-design roles.Verify using the company careers page or original job post where possible.If the source is only an aggregator, mark verification_status as "unclear". ``` The better version gives the agent a clear definition of success. --- ### 2. Input data You can run Agent with only a query, or you can give it rows to enrich. Example input: ```language-json { "data": [ { "company": "TensorZero", "domain": "tensorzero.com" }, { "company": "Capy", "domain": "capy.ai" } ]} ``` This is useful when you already have a list and want the agent to add missing fields. For example: ``` For each input company, find whether they are hiring design engineers, summarize the product, and return job URLs and founder LinkedIn URLs. ``` --- ### 3. Output schema This is where Agent becomes production-friendly. Instead of asking for a text answer, ask for structured JSON. Example schema: ```language-json { "type": "object", "properties": { "active_roles": { "type": "array", "maxItems": 10, "items": { "type": "object", "properties": { "company": { "type": "string" }, "role": { "type": "string" }, "company_category": { "type": "string" }, "fit_score": { "type": "string" }, "location": { "type": "string" }, "compensation": { "type": "string" }, "job_url": { "type": "string" }, "careers_url": { "type": "string" }, "verification_status": { "type": "string", "enum": ["active", "unclear", "closed"] }, "evidence": { "type": "string" }, "why_relevant": { "type": "string" } }, "required": [ "company", "role", "fit_score", "location", "verification_status", "evidence" ] } }, "excluded_roles": { "type": "array", "items": { "type": "object", "properties": { "company": { "type": "string" }, "role": { "type": "string" }, "reason": { "type": "string" } }, "required": ["company", "role", "reason"] } } }, "required": ["active_roles", "excluded_roles"]} ``` This gives you clean data that can be sent to a CRM, spreadsheet, database, workflow automation tool, or internal product dashboard. --- ### 4. Verification and scoring The biggest issue in agentic research is not finding data. It is trusting the data. So every serious Agent workflow should include: ``` verification_statussource_urlevidencelast_checked_dateconfidence_scorereason_for_exclusion ``` For hiring, fundraising, healthcare, compliance, or market research, verification is not optional. It is the difference between a fun demo and a production-grade research system. --- ## How to test Exa Agent in Google Colab Colab is a good place to test the Exa Agent API because you can quickly install the SDK, run prompts, inspect JSON, and iterate. ### Step 1: Install the SDK ``` !pip install exa-py ``` ### Step 2: Add your API key ``` import osfrom getpass import getpassos.environ["EXA_API_KEY"] = getpass("Enter EXA_API_KEY: ") ``` ### Step 3: Create an Agent run ``` import jsonfrom exa_py import Exaexa = Exa(api_key=os.environ["EXA_API_KEY"])run = exa.beta.agent.runs.create( betas=["agent-2026-05-07"], query=""" Find AI infrastructure companies currently hiring founding designers, founding product designers, or founding design engineers. Include only active roles. Exclude closed, removed, expired, or non-design roles. Verify using company careers pages or original job posts where possible. """, output_schema={ "type": "object", "properties": { "active_roles": { "type": "array", "maxItems": 10, "items": { "type": "object", "properties": { "company": {"type": "string"}, "role": {"type": "string"}, "location": {"type": "string"}, "compensation": {"type": "string"}, "job_url": {"type": "string"}, "verification_status": { "type": "string", "enum": ["active", "unclear", "closed"] }, "evidence": {"type": "string"} }, "required": [ "company", "role", "location", "verification_status", "evidence" ] } } }, "required": ["active_roles"] }, effort="low")print(run.id)print(run.status) ``` ### Step 4: Poll until complete ``` finished = exa.beta.agent.runs.poll_until_finished( run.id, betas=["agent-2026-05-07"], poll_interval=4000)print("Status:", finished.status)if finished.output: print(json.dumps(finished.output.structured, indent=2))else: print(json.dumps(finished.model_dump(), indent=2)) ``` For initial testing, use: ``` effort="low" ``` For more serious research, use: ``` effort="medium" ``` For production-quality deep research, use: ``` effort="auto" ``` Our test used Auto and completed at **$0.16**, but cost will vary depending on query complexity, number of sources, enrichment depth, and schema requirements. --- ## What about Exa MCP? Exa MCP is not the same as Exa Agent. MCP is best when you want to give your AI coding assistant search capabilities. For example, in Cursor: ```language-json { "mcpServers": { "exa": { "url": "https://mcp.exa.ai/mcp" } }} ``` With an API key: ```language-json { "mcpServers": { "exa": { "url": "https://mcp.exa.ai/mcp", "headers": { "x-api-key": "YOUR_EXA_API_KEY" } } }} ``` To enable multiple tools: ```language-json { "mcpServers": { "exa": { "url": "https://mcp.exa.ai/mcp?tools=web_search_exa,web_fetch_exa,web_search_advanced_exa", "headers": { "x-api-key": "YOUR_EXA_API_KEY" } } }} ``` MCP is ideal for: ``` CursorClaude DesktopClaude CodeVS CodeCodexWindsurfGemini CLIZedWarpRoo Code ``` The default tools include `web_search_exa` and `web_fetch_exa`, while `web_search_advanced_exa` can be enabled for more advanced filtering and search controls. --- ## Agent API vs MCP: when to use what | Need | Use | | Build a structured prospecting list | Exa Agent | | Enrich companies, people, jobs, or markets | Exa Agent | | Return schema-validated JSON | Exa Agent | | Run async research workflows | Exa Agent | | Give Cursor/Claude/Codex web search | Exa MCP | | Fetch web pages inside an AI coding assistant | Exa MCP | | Add Exa search tools to an AI client | Exa MCP | | Test quickly in Colab | Exa Agent API | | Build production workflow automation | Exa Agent API + Search API | The simple rule: ``` Use MCP when the AI assistant needs tools.Use Agent when your product needs structured research output. ``` --- ## Jatin’s blueprint for anyone starting with this product Here is the practical path I would follow. ### Phase 1: Start with a narrow use case Do not begin with “build a research agent.” Begin with one painful workflow. Examples: ``` Find healthcare product manager jobs posted today.Find AI infrastructure startups hiring founding designers.Find newly funded companies in a specific category.Find top HEDIS measures for a specific population.Enrich a list of companies with founder, funding, hiring, and product data. ``` A narrow workflow makes evaluation easier. --- ### Phase 2: Define the output before the prompt Most people start with the prompt. For agentic products, start with the output. Ask: ``` What fields do I need?Which fields must be verified?Which fields can be inferred?Which fields need citations?What makes a result unacceptable? ``` For example, a job-search agent should not just return job titles. It should return: ``` companyrolelocationposted_datesource_urljob_urlcompensationverification_statusevidencereason_for_fit ``` This turns the agent into a system, not a chatbot. --- ### Phase 3: Run cheap tests first Use low effort first. ``` effort="low" ``` Then compare output quality. If the result misses too much, move to: ``` effort="medium" ``` Use Auto only when you are ready for deeper research or production-level runs. --- ### Phase 4: Add exclusion logic Good research agents are not only good at finding things. They are good at rejecting bad results. For example: ``` Exclude closed jobs.Exclude aggregator-only results unless no direct source exists.Exclude non-founding roles.Exclude companies that are not AI infrastructure.Put rejected results into excluded_roles with a reason. ``` This improves trust dramatically. --- ### Phase 5: Add human review checkpoints For early product development, do not fully automate decisions. Use the agent to produce: ``` recommendedunclearexcluded ``` Then let a human review the unclear cases. This is especially important for healthcare, hiring, compliance, financial research, and anything involving people data. --- ### Phase 6: Convert the workflow into a product surface Once the Agent workflow works, the product UI can be simple: ``` User queryFiltersEffort levelOutput schemaRun historyCostStructured resultsEvidence viewerExport to CSV / CRM / Notion / Airtable ``` The Exa Agent web UI already hints at this pattern with Query, Add Data, Effort, Output Format, Run, and Past Runs. That is a strong product pattern: make research repeatable, inspectable, and exportable. --- ## What an article or product launch should also include A strong article about this product should include five extra sections. ### 1. Cost awareness Agent runs are usage-based. Always show cost per run and allow users to choose effort level. A good product should show: ``` Estimated cost before runActual cost after runNumber of searchesAgent compute usageCost by component ``` This builds user trust. --- ### 2. Reproducibility Users should be able to rerun the same research later. Include: ``` run_idqueryinput dataschemaeffort leveltimestampoutputsource evidence ``` This is important because web data changes. --- ### 3. Grounding and evidence Every result should answer: ``` Why did the agent include this?Where did it find the information?How confident is it?When was it checked? ``` Without grounding, agentic research becomes hard to trust. --- ### 4. Workflow continuation One powerful feature is continuing from a previous run. Example: ``` Now narrow this list to companies hiring in San Francisco. ``` or: ``` Find 10 more companies like these, but only Seed or Series A. ``` This makes Agent feel less like a one-shot search and more like a research partner. --- ### 5. Production architecture A real product could look like this: ``` Frontend ↓Research request form ↓Backend API ↓Exa Agent run ↓Polling / streaming status ↓Structured JSON result ↓Verification layer ↓Database ↓Review UI / export / CRM sync ``` For more advanced workflows: ``` Exa MCP → coding assistant researchExa Agent → structured enrichmentExa Search API → low-latency searchInternal database → memory and deduplicationHuman review → quality control ``` --- ## Final takeaway Exa Agent is useful when the task is bigger than search. Our test showed that it can take a broad research query, discover relevant companies, enrich them with role and compensation data, exclude bad matches, and return a structured result at a reasonable test cost. Exa MCP is useful when you want AI assistants like Cursor, Claude, Codex, or VS Code to access Exa search tools directly. For someone starting on this product, the best path is: ``` Start with one narrow workflow.Define the output schema.Test in Colab.Run with low effort.Add verification and exclusions.Move to structured JSON.Build a review/export UI.Then connect MCP for coding-agent workflows. ``` The big opportunity is not just “AI search.” The opportunity is **agentic research infrastructure**: systems that can search, reason, verify, structure, and enrich information into outputs that teams can actually use. ## CONTINUE EXPLORING * [Agentic RAG: Practical Applications](https://mohammadjazim.blog/2024/12/06/agentic-rag-redefining-knowledge-retrieval-with-practical-applications/) * [Building Multi-Step AI Agents with Claude’s MCP](https://mohammadjazim.blog/2024/11/30/how-to-build-multi-step-ai-agents-with-claudes-mcp-update/) * [Vertical AI Agents and the SaaS Revolution](https://mohammadjazim.blog/2024/12/08/vertical-ai-agents-the-300-billion-saas-revolution/) The post [From Search API to Research Agents: A Practical Blueprint for Building with Exa Agent and Exa MCP](https://mohammadjazim.blog/2026/06/07/building-ai-research-agents-exa-agent-mcp/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## I Am a Creative - Link: https://mohammadjazim.blog/2026/06/06/i-am-a-creative/ - Published: 2026-06-06T20:06:43+05:30 - Author: Mohammad Jazim I Am a Creative……. Not because it sounds impressive. Not because it fits neatly on a LinkedIn headline. Not because I want to separate myself from “non-creative” people. I say it because it is the closest word I have for the way I move through the world. Creativity, for me, is not a clean system. It is not a five-step framework. It is not always research, ideation, execution, review. Sometimes it is that. Sometimes it behaves. Most of the time, it doesn’t. Most of the time, it arrives like weather. You can prepare for it. You can watch the sky. You can carry an umbrella. But you cannot command the rain. ### The work looks mysterious because it is There are people who can explain their creative process beautifully. They have boards, notes, rituals, references, methods. They know exactly how they got from problem to solution. I respect that. I even admire it. But that is not always how it works for me. Sometimes I sit with a problem for days and nothing happens. I read, walk, scroll, avoid, overthink, and pretend to be productive. Then suddenly, while brushing my teeth or making tea or staring at nothing, the answer appears. Not politely. Not gradually. It just lands. And when it lands, I know. That is the strange part. The idea may have taken ten seconds to arrive, but it needed the previous ten years to become possible. This is what people often misunderstand about creative work. They see the moment of output and assume that was the work. They don’t see the silent loading screen behind it. The years of taste-building, failed attempts, stolen observations, tiny embarrassments, unfinished drafts, private obsessions, and half-formed thoughts. The idea looks sudden. It is not sudden. ### Sometimes the best ideas come too early One of the hardest lessons I have learned is this: do not always share the idea the moment it comes. Fresh ideas are fragile. They look obvious after they are born, but before that, they need protection. Sometimes I have blurted out an idea too soon because I was excited. I wanted others to feel what I felt. I wanted the room to light up. Sometimes it worked. Often it didn’t. Not because the idea was bad, but because the room was not ready. The timing was wrong. The context was thin. The meeting before the meeting was not the meeting. Creativity is not only about having the idea. It is also about knowing when to reveal it. Enthusiasm is powerful, but badly timed enthusiasm can make a good idea look immature. So I have learned, slowly and painfully, to let some ideas sit. To let them gather weight. To let myself test whether I still believe in them after the first rush has passed. ### Meetings are not the enemy, but they often pretend to be work Some meetings help. A good conversation can sharpen a thought. A smart question can save a project. The right person saying one honest sentence can unlock the whole thing. But many meetings are just fear wearing a calendar invite. We gather because we are nervous. We discuss because deciding feels risky. We align because ownership is uncomfortable. We create more rooms around the work instead of entering the work itself. For a creative person, this can be exhausting. Not because creatives are precious or allergic to collaboration. The best creative work often needs other people. But there is a difference between collaboration and erosion. Collaboration improves the work. Erosion slowly removes the soul from it. ### Don’t ask me for a perfect process I have a process, of course. Everyone does. But mine is not always respectable. Sometimes my process is discipline. Sometimes it is panic. Sometimes it is avoidance until avoidance becomes unbearable. Sometimes it is walking in circles. Sometimes it is consuming everything related to the problem. Sometimes it is refusing to look at the problem at all. Sometimes the work comes from focus. Sometimes it comes from surrender. And sometimes it comes because the deadline is now close enough to become a threat. I am not proud of that, but I am honest about it. There is a strange adrenaline in postponement. A dangerous confidence that says,“ You will figure it out.” And often, I do. That is the problem. The bad habit keeps getting rewarded. But make no mistake: delay is not laziness alone. Sometimes delay is fear. Fear that the thing in your head will shrink when it enters the world. Fear that your taste is bigger than your ability. Fear that this time, the gift will not show up. ### Creatives recognize other creatives There is a quiet recognition that happens between creative people. You see it in the way someone notices details others miss. You hear it in the way they describe a problem. You feel it in their dissatisfaction with the obvious answer. Creatives are often difficult, not because they want to be, but because they are haunted by what something could become. They can respect the brief and still feel the ghost of a better brief. They can deliver the work and still mourn the version that almost existed. They can receive praise and immediately think of the flaw no one noticed. That is the curse of taste. The better your taste becomes, the harder it is to enjoy your own work. You compare your small thing to the giants. You look at your sentence and think of Baldwin. You look at your product and think of Jobs. You look at your film and think of Kurosawa. You look at your animation and think of Miyazaki. And then you return to your own work and think: this is fine, I guess. But fine is not nothing. Fine is often the bridge to better. ### I am not an artist I am a creative. There is a difference, at least in my mind. An artist may answer first to the work. A creative often answers to the world around the work: the client, the user, the market, the deadline, the team, the business, the brief, the format, the platform. A creative makes within constraints. And constraints are not always enemies. Sometimes they are the only reason the work becomes real. Still, a part of me has always wanted the purity of art. To make without explanation. To create without a deck. To not have to translate instinct into strategy. But that is not the life I chose. Or maybe it chose me. I make things that must live in the world. They must be understood. Used. Sold. Shared. Remembered. They must carry meaning, but also function. They must be beautiful, but also useful. That tension is where I live. ### Intuition is not the opposite of intelligence People often treat intuition like a soft thing. It is not. Intuition is compressed experience. It is pattern recognition moving faster than language. It is the mind saying, “This is right,” before it can explain why. That does not mean intuition is always correct. It can be biased, vain, impatient, dramatic, and wrong. But it is not random. A creative learns to listen to intuition without worshipping it. To trust the spark, then test it. To follow the feeling, then shape it with reason. The first version may come from mystery. The final version still needs craft. ### The work saves me from the fear of the work The hardest part is often not doing the work. The hardest part is standing outside the work, imagining it. Once I enter it, something changes. The anxiety has somewhere to go. The fog becomes material. The problem becomes physical. A sentence can be cut. A layout can be moved. A product flow can be simplified. A name can be tested. A bad idea can be replaced. Working saves me from worrying about work. This is something I have to relearn constantly. The fear before the work is abstract and endless. The work itself is specific. And specific problems can be solved. ### The small gift I am a creative, and like many creatives, I live with the quiet fear that one day the gift will disappear. That the ideas will stop coming. That the taste will remain but the ability will fade. That I will still know what good looks like but no longer be able to reach it. Maybe every creative carries this fear. Maybe it is part of the fuel. So we keep making. Not because everything we make will be great. Most of it will not. Some of it will be useful. Some of it will be forgotten. A few things may matter to someone, somewhere, for reasons we may never fully know. And maybe that is enough. To make something that did not exist before. To leave behind one sentence, one idea, one interface, one story, one small act of beauty or clarity that enters another person’s mind and stays there. That is the promise. That is the risk. That is why I keep returning to the blank page, the empty canvas, the unresolved brief, the impossible problem. I am a creative. I do not always understand the work. But I know I am here to make it. The post [I Am a Creative](https://mohammadjazim.blog/2026/06/06/i-am-a-creative/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## Epic Agent Factory Is Not an AI Announcement. It’s a Claim on Healthcare’s Execution Layer. - Link: https://mohammadjazim.blog/2026/05/31/epic-agent-factory-is-not-an-ai-announcement-its-a-claim-on-healthcares-execution-layer/ - Published: 2026-05-31T13:54:22+05:30 - Author: Mohammad Jazim The healthcare industry may be misunderstanding what Epic’s Agent Factory announcement actually represents. Most discussions have focused on the AI itself—the agents, the models, the automation. But the real story is much bigger. Agent Factory is not simply another AI feature added to an EHR. It is a strategic move to redefine who owns workflow execution in healthcare. For years, healthcare technology has been organized around systems of record. EHRs stored clinical data. Revenue cycle systems stored financial data. Scheduling systems stored operational data. Vendors built applications around those systems, extracting data, generating insights, and automating specific tasks. The next decade will likely be defined by something different. The competition is shifting from “Who owns the data?” to “Who owns the execution layer?” ## The Healthcare Agentic Stack To understand why this matters, it helps to look at healthcare technology as a layered stack. ### Layer 0: Infrastructure At the foundation are cloud platforms, storage, security, networking, and compute. These layers are essential but increasingly commoditized. No health system chooses an EHR because of its storage architecture. ### Layer 1: Systems of Record This is where traditional EHRs built their dominance. Systems such as Epic, Athenahealth, Oracle Health, and Meditech answer fundamental questions: * What happened? * Who performed the action? * When did it occur? Appointments, diagnoses, medications, orders, and claims all live here. Historically, this was the center of healthcare technology. ### Layer 2: Data Normalization As health systems became more complex, a new layer emerged. Enterprise data platforms, FHIR-based architectures, OMOP models, and analytics vendors created normalized views of fragmented healthcare data. This layer solved a critical problem: How do we create a unified patient view across multiple systems? For years, many vendors built significant value here. ### Layer 3: Context This is the layer most organizations underestimate. Data tells us what happened. Context tells us what should happen next. A patient record may indicate diabetes. Context reveals that the patient has missed their last appointment, is overdue for a retinal exam, recently changed insurance plans, and has an unresolved referral. Agents cannot operate effectively on raw data alone. They require context. This is where the strategic importance of Agent Factory begins to emerge. Epic is not simply trying to own data. Epic is attempting to own context. ### Layer 4: Permissions Knowing what should happen is not enough. An agent must know what it is allowed to do. Can it read a chart? Can it schedule an appointment? Can it send a patient message? Can it initiate a prior authorization workflow? As autonomous systems become more common, permissions become one of the most valuable assets in healthcare technology. ### Layer 5: Workflow Healthcare runs on workflows. Referral management. Prior authorization. Discharge planning. Care gap closure. Revenue cycle operations. Clinical documentation. Historically, these workflows were managed by informatics teams, operational leaders, Epic analysts, and specialized vendors. This is where much of healthcare’s operational complexity lives. ### Layer 6: Agent Runtime This is where Agent Factory enters the picture. The runtime is responsible for: * Observing events * Reasoning about context * Planning actions * Executing workflows * Monitoring outcomes A radiology report is finalized. An event is generated. An agent reviews the recommendation, checks patient history, creates follow-up tasks, notifies care teams, and tracks completion. The agent is not the innovation. The runtime is. ### Layer 7: Intelligence This remains a major opportunity for healthcare AI vendors. Specialized clinical intelligence, oncology decision support, CDI optimization, prior authorization expertise, and revenue cycle reasoning remain difficult to commoditize. Owning the runtime does not automatically mean owning the best intelligence. ### Layer 8: Enterprise Orchestration This may ultimately become the most valuable layer of all. Healthcare workflows rarely stay within a single platform. A patient’s journey touches: * EHRs * Payers * CRM systems * Contact centers * Revenue cycle platforms * ERP systems * Workforce management tools Someone must coordinate activity across all of them. The organization that masters orchestration may ultimately become more influential than any individual system of record. ## What This Means for Health Systems Large health systems may become builders rather than buyers. Historically, automation often required purchasing a vendor solution, integrating it, implementing it, and managing a lengthy deployment cycle. Agent platforms promise a different future. Health systems identify a workflow problem, configure an agent, pilot it, monitor performance, and deploy rapidly. This will likely create entirely new organizational functions: * AI Operations * Agent Governance * Workflow Engineering * Clinical Automation Teams The most successful health systems may increasingly resemble software companies. ## What This Means for EHR Vendors Epic’s strategy appears clear. Move from: System of Record To: System of Record + Context + Permissions + Workflow + Agent Runtime Other EHR vendors face an important decision. Do they build competing agent platforms? Or do they become open ecosystems that allow external agents to operate on top of their data? The answer will shape the competitive landscape for years. ## What This Means for Healthcare AI Vendors The impact will not be uniform. Vendors whose primary value proposition is workflow automation may face significant pressure. If an EHR can provide native agents that automate referrals, scheduling, documentation routing, inbox triage, or care coordination, many standalone workflow tools become vulnerable. However, vendors with differentiated intelligence, cross-EHR visibility, governance capabilities, or enterprise orchestration strengths may become even more valuable. The winners will not necessarily be those with the best access to data. They will be those that own capabilities the platform cannot easily replicate. ## The Real Question For years, healthcare technology companies competed around data. Then the industry shifted toward analytics and insights. The next era appears to be centered on execution. Data → Context → Permission → Workflow → Action → Outcome Agent Factory is not simply an AI announcement. It is a signal that healthcare is entering a new phase where the most important platform may not be the one that stores information, but the one that decides—and executes—what happens next. That is the real battleground now emerging across healthcare technology. ## CONTINUE EXPLORING * [Epic UGM 2025: When EHRs Stopped Being Just Records](https://mohammadjazim.blog/2025/10/11/epic-ugm-2025-when-ehrs-stopped-being-just-records/) * [In Healthcare, MVP Isn’t Enough. It Has to Be MCSP.](https://mohammadjazim.blog/2026/03/16/in-healthcare-mvp-isnt-enough-it-has-to-be-mcsp/) * [Understanding Healthcare AI: From Documentation to Cognition](https://mohammadjazim.blog/2026/05/14/understanding-healthcare-ai-from-documentation-to-cognition/) The post [Epic Agent Factory Is Not an AI Announcement. It’s a Claim on Healthcare’s Execution Layer.](https://mohammadjazim.blog/2026/05/31/epic-agent-factory-is-not-an-ai-announcement-its-a-claim-on-healthcares-execution-layer/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog). ## Understanding Healthcare AI: From Documentation to Cognition - Link: https://mohammadjazim.blog/2026/05/14/understanding-healthcare-ai-from-documentation-to-cognition/ - Published: 2026-05-14T01:07:11+05:30 - Author: Mohammad Jazim Most people still think the healthcare AI race is about scribes. Faster notes. Better transcription. Cleaner documentation. That is the visible layer. . . . But underneath it, something much larger is happening. Healthcare AI is splitting into architectural layers. And the layer capturing the most durable value may not be the one most people are watching. --- The market narrative today is still dominated by application-level thinking. “AI that writes clinical notes.” “AI copilots for physicians.” “Ambient documentation.” Useful framing. But strategically incomplete. Because every major software market eventually undergoes the same transition: Applications capture attention first. Infrastructure captures the enduring margin pool later. Healthcare AI is now entering that transition. --- The easiest way to understand the shift is this: Healthcare AI is separating into three distinct layers. Layer 1 captures documentation. Layer 2 captures workflow orchestration. Layer 3 captures cognition itself. And the strategic logic of each layer is completely different. --- ### Layer 1 — Documentation AI This is the current AI scribe wave. Ambient listening. Clinical note generation. Conversation-to-documentation workflows. This layer solved a real problem. Burnout. Administrative overload. After-hours charting. And adoption is real. Health systems want relief. Clinicians want time back. The market rewarded that urgency aggressively. But structurally, Layer 1 is already compressing. Why? Because documentation alone is becoming commoditized. When Epic launches native AI charting… when Athena bundles ambient AI into the EHR… when physician networks begin offering scribes for free… the application layer starts losing pricing power. The infrastructure owners have entered the room. And once platform incumbents absorb the interface layer, standalone tools become vulnerable very quickly. . . . This is what most markets look like before consolidation. --- But the deeper issue is architectural. Documentation AI is retrospective by nature. The AI listens _after_ clinical cognition has already happened. The physician thinks first. The AI records second. That means the system captures workflow residue… not decision-making itself. And historically, the highest-value infrastructure layers are usually the ones closest to operational decision loops. Not documentation exhaust. --- ### Layer 2 — Workflow Intelligence This is where the market becomes economically interesting. The AI no longer stops at note generation. Now it touches: coding billing prior authorization clinical documentation integrity quality measures referrals revenue cycle orchestration. The product is no longer: “AI that writes notes.” It becomes: “AI that converts clinical conversations into operational outcomes.” That distinction matters enormously. Because Layer 2 directly impacts revenue realization. And revenue-linked infrastructure tends to become sticky very quickly. --- This is where healthcare AI starts resembling enterprise operating systems rather than productivity tools. The workflow becomes the moat. Not the note. Once coding logic, compliance pathways, and payer interactions become embedded into downstream orchestration… switching costs increase dramatically. The infrastructure becomes operationally entangled with the organization itself. --- But Layer 2 also creates a new competitive tension. The battle is no longer against startups. It becomes a collision with: EHR vendors payer-owned RCM platforms enterprise workflow incumbents and vertically integrated healthcare infrastructure companies. Which means the market is no longer competing for software adoption. It is competing for workflow ownership. That is a fundamentally different war. --- And then comes Layer 3. The layer most people still underestimate. --- ### Layer 3 — Clinical Cognition Infrastructure This is where healthcare AI stops documenting care… and starts participating inside care delivery itself. Not passive systems. Active reasoning systems. Real-time guidance during encounters. Governed agentic execution. Live clinical reasoning support. AI operating _inside_ the decision loop. This is not simply a better scribe. It is an entirely different infrastructure category. --- The core problem here is no longer intelligence. LLMs are already capable enough. The bottleneck is governed execution. Can the system safely act? Can it validate decisions before execution? Can it maintain auditability? Can it operate under regulatory scrutiny? Can organizations trust machine participation inside clinical workflows? . . . That is the real infrastructure problem emerging now. --- And this is where the market starts looking less like SaaS… and more like cloud infrastructure. A decade ago, cloud computing underwent a similar transition. Applications captured early excitement. But orchestration, observability, governance, and runtime infrastructure ultimately captured the durable strategic position. Healthcare AI appears to be moving through the same cycle. Except now the runtime governs clinical decisions instead of servers. --- This changes the definition of the moat entirely. The moat is no longer: best note generation best UI best summarization The moat becomes: governance orchestration runtime safety clinical validation auditability and trust infrastructure. Because once AI agents begin taking operational action, the organization no longer buys intelligence alone. It buys controlled machine participation. --- And that creates the most important shift of all. The healthcare AI battle is quietly moving from: “Who documents care?” to: “Who governs AI participation inside care delivery itself?” That is the real strategic transition happening underneath the market. --- The long-term winners may not be the companies writing the best clinical notes. They may be the companies building the runtime layer that governs how agentic systems safely operate across regulated healthcare environments. Because in every major technology cycle… applications create visibility first. Infrastructure captures durability later. And healthcare AI is beginning to cross that boundary right now.[](https://www.linkedin.com/in/mohammadjazim/) ## CONTINUE EXPLORING * [EMR Bloat Is Costing Us: Time, Money—and Patient Trust](https://mohammadjazim.blog/2025/10/11/emr-bloat-is-costing-us-time-money-and-patient-trust/) * [Why AI in Mammography Is Moving From Innovation to Standard of Care](https://mohammadjazim.blog/2026/03/16/why-ai-in-mammography-is-moving-from-innovation-to-standard-of-care/) * [Epic Agent Factory: Healthcare’s Execution Layer](https://mohammadjazim.blog/2026/05/31/epic-agent-factory-is-not-an-ai-announcement-its-a-claim-on-healthcares-execution-layer/) The post [Understanding Healthcare AI: From Documentation to Cognition](https://mohammadjazim.blog/2026/05/14/understanding-healthcare-ai-from-documentation-to-cognition/) appeared first on [Mohammad Jazim](https://mohammadjazim.blog).