How much does AI consulting cost?

BlokAI's engagements range from $5,000 to $75,000 depending on scope. Simple automations and LLM integrations start around $5K–$15K. Custom AI agent systems and full data infrastructure projects run $30K–$75K. We scope every project before committing to a price.

What does BlokAI build?

BlokAI builds AI agents, LLM applications, RAG systems, automation pipelines, and data infrastructure for startups and SMBs. We take projects from architecture to production — not demos, not prototypes.

Is BlokAI based in Japan?

Yes. BlokAI is a solo studio run by Kent Tran, based in Tokyo, Japan. We work with clients globally in English.

What is RAG and why does my business need it?

RAG (Retrieval-Augmented Generation) lets AI systems search your own documents, databases, or knowledge bases before answering — instead of relying only on training data. It powers AI customer support, internal search tools, and sales enablement systems that are accurate and up-to-date.

Building an AI Content Pipeline That Runs on $0/Day in LLM Costs

"Meta AI is now available across Facebook, Instagram, WhatsApp, and Messenger, with Meta AI Studio enabling businesses to create custom AI personas — reaching over 700 million people." — Meta, July 2025

The headline is real, and I'll explain exactly how we got there. This is a case study of a content pipeline we built for a client where the ongoing LLM inference cost is effectively zero, despite the system producing structured content every day.

It requires some upfront investment and specific architectural choices. But the numbers are worth examining, especially for businesses where AI content or data processing needs to run at scale.

The Client and the Problem

A media monitoring company — they track news and social content in specific industry sectors for their corporate clients, and produce daily briefings. Before this project, the briefings were assembled manually by a small editorial team: find relevant stories, categorise them, write summaries, assemble into a structured daily report, deliver to clients.

The team was spending roughly 6 hours daily on this process. The goal: automate the routine assembly while keeping human editorial judgment in the loop for quality and final review.

This is a good automation candidate: high-frequency, well-structured output requirements, significant manual time, and the quality bar is "good enough to reduce human work by 80%" rather than "indistinguishable from expert humans."

The Architecture

Stage 1: Content Collection and Filtering (Zero LLM Cost)

A scraper network collects articles and social content from ~200 defined sources on a schedule. Initial filtering uses traditional NLP (TF-IDF relevance scoring against topic keywords, not LLMs) to remove clearly irrelevant content. This cuts ~85% of raw volume.

LLM cost: $0. This stage uses no language models — just keyword matching and classical NLP.

Stage 2: Classification and Tagging (Local Model)

Remaining content needs to be classified into topic categories and tagged with relevant entities (companies, people, topics). This is a well-defined classification task with a defined output structure — not an open-ended generation problem.

We fine-tuned a small model (Phi-3 Mini, 3.8 billion parameters) on 2,000 labelled examples from the client's historical content. The fine-tuned model runs on a single GPU instance (an AWS g5.xlarge at ~$1.00/hour). Processing a full day's content takes approximately 25 minutes of inference time.

Daily LLM cost: ~$0.42 (25 minutes of GPU time). Rounds to zero at the scale of meaningful business costs. Importantly, because it's a fine-tuned local model, zero API cost to any external provider.

Stage 3: Summary Generation (Cached and Batched)

Each relevant article needs a 2-3 sentence summary. This is the most expensive stage — it requires generative LLM output.

The key insight: content recycles. The same news story often appears across multiple sources with slight variations. If we've already summarised a story from Source A, we don't need to regenerate for Source B.

We use a deduplication layer (semantic similarity via embeddings) before the summarisation step. On average, this reduces unique items requiring summarisation to 35-40% of filtered volume.

For the actual summarisation, we use a quantised Llama 3 8B model running on the same GPU instance. Faster than API-based models for this simple task, zero per-token cost.

Daily LLM cost: $0 (runs on the same GPU instance, within the same compute window).

Stage 4: Briefing Assembly and Formatting (Template + Light LLM)

The assembled, summarised, classified content is formatted into the client's briefing template. Section headers, lead items, secondary items, entity mentions, source citations — all assembled programmatically from structured data.

One optional LLM call: a "daily theme" synthesis that identifies the top 2-3 overarching narratives across the day's content. This is an API call (GPT-4o mini) that runs once per day per client. At ~2,000 tokens per call, with ~12 clients, this is approximately $0.015/day across the entire client base.

Daily LLM cost: ~$0.015. Effectively zero.

Stage 5: Human Review

The assembled briefing goes to the editorial team. Instead of building from scratch, they're reviewing and editing a draft. What was 6 hours of work is now 45-60 minutes of review and light editing.

The Total Cost Picture

Infrastructure:

GPU instance (g5.xlarge): ~$1.00/hour × ~30 min/day = $0.50/day
Scraper infrastructure: ~$80/month
Storage and orchestration: ~$40/month

LLM API costs:

GPT-4o mini synthesis: ~$0.015/day × 30 days = ~$0.45/month

Total ongoing cost: ~$270/month

For a team that was spending 6 editorial hours/day (at ~$45/hour loaded cost = $270/day), that's a 30:1 cost reduction on the labour replaced.

What Made "Zero API Cost" Possible

The right tasks for the right tools. Not every NLP task needs a frontier language model. Classification, summarisation of simple articles, entity extraction — small fine-tuned models handle these well. Reserve expensive frontier models for tasks that actually require their capability: complex reasoning, nuanced generation, handling novel situations. Fine-tuning instead of prompting. A 3.8B parameter model fine-tuned on your specific task often outperforms a 70B general model prompted for the same task, at 1/20th the inference cost. Deduplication before generation. The most expensive operation (generation) is avoided whenever possible through smart deduplication. Don't generate what you can reuse. Quantisation. Running models in 4-bit or 8-bit precision dramatically reduces memory requirements and speeds up inference at modest quality cost. For well-defined tasks where we've validated accuracy on our test set, the quality trade-off is acceptable. Batch processing. Instead of streaming queries to an API in real time, we batch process on a schedule. This allows us to use spot/preemptible GPU instances (50-70% cheaper than on-demand) and optimise for throughput rather than latency.

The Limits of This Approach

This architecture works because the tasks are well-defined, the volume is predictable, and accuracy requirements are "good enough for human review" rather than "perfect."

It would not work for:

Use cases requiring frontier model reasoning quality
Real-time, low-latency user-facing interactions
Tasks where fine-tuning training data isn't available
Cases where output quality can't be validated against a test set

The investment required upfront: time and cost to create fine-tuning training data, time to train and evaluate the local models, and infrastructure complexity (running local GPU instances is more work than calling an API).

The payoff: predictable, low-cost infrastructure that scales linearly rather than per-token.

For high-volume, well-defined AI tasks — especially content processing, classification, or data extraction at scale — this architecture is worth serious consideration.

Want to implement AI in your business? Book a 30-minute architecture call at blok-ai.com.