Have you ever spent 15 minutes scheduling a meeting just to explain something that could have been a 90-second screen recording? Yeah. That was my everyday reality — and the reason I built OpenKap.

The Problem I Kept Running Into

I was working with a small, async-first team. We were distributed across time zones, moving fast, and constantly needed to share context — bug reproductions, quick design feedback, “hey, look at this weird behavior” moments, product demos for stakeholders.

The obvious solution was Loom. We tried it. And sure, it works. But over time, the friction piled up:

• The free plan is capped at 5-minute recordings and a limited number of videos
• Pricing jumps significantly once you scale beyond a handful of users
• It felt bloated — AI summaries, editing suites, engagement analytics — features we didn’t need and were paying for anyway
• For a small team of 4-8 people, it was overkill

We didn’t need a video platform. We needed a fast, frictionless way to record our screen and share a link. That’s it.

What I Built Instead

OpenKap is a screen recording tool built for small teams who want to communicate faster without adding more meetings to the calendar.

Here’s the core loop:

1. Install the Chrome extension — takes about 10 seconds
2. Hit record — choose your capture area and start talking immediately, no waiting
3. Share the link — the moment you stop recording, your link is ready to paste into Slack, Notion, Linear, email, anywhere

That’s it. Record, link, done. Under 60 seconds from idea to shared video.

Why It’s a Great Loom Alternative for Small Teams

Speed over features. Loom has evolved into a full async video platform. That’s great for enterprises, but small teams don’t need a dashboard full of engagement stats. OpenKap does one thing really well: get your recording shareable as fast as possible.

Generous free tier. You get 5 recordings with shareable links right out of the box, no credit card required. For many small teams or solo devs, that covers everyday needs.

Flat, honest Pro pricing. The Pro plan is $8/month for unlimited recordings, unlimited length, unlimited workspaces, and team collaboration. No per-seat pricing surprises. No “contact sales” walls.

Infinite storage on Pro. No more worrying about your library filling up or having to delete old recordings to make space.

Screenshot annotation. Beyond video, you can annotate and highlight screenshots before sharing — great for quick UI feedback without recording a full video.

The Part I’m Most Excited About: Claude AI + MCP Integration

This is where things get genuinely interesting. OpenKap integrates with Claude AI via the Model Context Protocol (MCP). You can connect OpenKap to Claude Code or any MCP-compatible tool and literally talk to your videos.

Ask things like:

• “What bugs were reported in this video?”
• “Summarize this product demo for me”
• “What was discussed at the 3-minute mark?”
• “What feedback did the team leave in comments?”

For engineering teams already using Claude Code, this is a game-changer. You can reference a video URL in your Claude session and get instant transcription, summaries, and comment threads without ever leaving your workflow.

claude mcp add openkap -- npx tsx mcp-server/server.ts

One command. Done.

Who Is OpenKap For?

OpenKap is built for:

• Small dev teams who want to share bug reproductions or code walkthroughs without scheduling a call
• Designers giving quick feedback on UI without back-and-forth Figma comments
• Product managers recording async demos for stakeholders
• Founders and indie hackers moving fast and staying out of meetings
• Remote-first teams across time zones who need async-first communication

It’s trusted by developers, designers, and PMs at companies like Notion, Linear, Vercel, Stripe, Figma, Railway, and Supabase.

The Philosophy Behind It

I believe meetings are a tax on momentum. Every time someone schedules a 30-minute call to explain something visual, they’re burning time — for themselves and everyone else on the call. A well-made screen recording eliminates the need for most of those meetings.

But the tool has to be fast enough that it doesn’t create its own friction. If recording and sharing takes more than a minute, people won’t do it. They’ll just schedule the meeting.

OpenKap is designed around that constraint: the time from “I need to show someone this” to “link is in their Slack” should be under 60 seconds.

Try It

If you’re on a small team and you’re looking for a lighter, faster alternative to Loom, give OpenKap a shot.

The free plan requires no credit card, and you can be recording and sharing in under a minute. If you have feedback, I’d genuinely love to hear it — drop a comment below or reach out directly.

openkap.com

What’s your current async communication setup? Are you on Loom, something else, or still just scheduling calls? Let me know in the comments.

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Gemma 4 is Here: The Dawn of Local Multimodal Reasoning 🚀

For years, developers have lived in a bifurcated AI world. We had massive, capable, proprietary models locked behind APIs, and we had local, open-weights models that were good enough for basic tasks but struggled with complex reasoning and multimodal inputs.

With the release of Gemma 4, that gap hasn’t just narrowed; it’s practically vanished.

Gemma 4 brings features previously reserved for frontier API models—multimodal capabilities, a massive 128K context window, and a dedicated Reasoning Mode—straight to your local machine.

In this post, we’re going to break down the three model variants, explore what these new capabilities actually mean for everyday developers, and look at how to get started.

🏗️ The Three Variants: Which one is for you?

Google released Gemma 4 in three distinct sizes to cover the spectrum of developer needs:

1. Gemma 4 (Nano / Edge Class): The edge champion. Perfect for deploying on mobile devices, Raspberry Pis, or running silently in the background of a larger desktop app for basic autocomplete and routing tasks.
2. Gemma 4 (Standard / Mid-Class): The developer’s workhorse. If you’re running a MacBook Pro or a decent Windows/Linux rig with a mid-range GPU, this is your daily driver.
3. Gemma 4 (Large / Pro Class): The local powerhouse. Requires a beefy GPU setup but offers reasoning capabilities rivaling top-tier models.

🧠 The Game-Changer: Reasoning Mode

Perhaps the most exciting feature of Gemma 4 is Reasoning Mode.

Reasoning Mode introduces an internal “thinking” phase where the model evaluates approaches, self-corrects, and structures its logic before producing the final output.

Why this matters: You can now tackle complex algorithms, debugging, and architectural planning locally—without your data leaving your machine.

👁️ Multimodal Input: Seeing the Big Picture

Gemma 4 supports native multimodal input:

• UI to Code: Convert Figma screenshots into React/Tailwind
• Debugging: Combine screenshots + logs
• Accessibility: Generate alt-text locally

No need for multiple models—it’s one unified system.

📚 128K Context Window: The “Whole Codebase” Era

A 128K context window allows you to feed massive inputs:

• Entire repositories
• Documentation
• Issue tickets

The model understands system-level architecture—not just snippets.

🛠️ Getting Started Locally

Run with Ollama:

# Pull the standard variant for local dev
ollama run gemma4

Python Example (Multimodal + Reasoning Mode)

from transformers import AutoProcessor, AutoModelForCausalLM
import torch

# Load the model and processor
model_id = "google/gemma-4-standard-it"
processor = AutoProcessor.from_pretrained(model_id)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    torch_dtype=torch.bfloat16
)

# Multimodal input with Reasoning Mode
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://example.com/system-architecture.png"},
            {
                "type": "text",
                "text": "Analyze this architecture diagram and output a step-by-step plan to migrate it to serverless. Enable reasoning mode."
            }
        ]
    }
]

# Process and Generate
inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=4096,
    enable_reasoning=True  # The magic flag
)

print(processor.decode(outputs[0]))

🔮 What This Means for the Future

Gemma 4 is a statement: True developer autonomy is possible.

With local reasoning, vision, and massive context, we eliminate:

• API costs
• Privacy concerns
• Latency

We can build autonomous agents that run entirely on our hardware—securely processing sensitive data and private codebases.

The frontier is no longer locked in a distant data center.

With Gemma 4, the frontier is on your desk.

When the autonomous customer‑support bot at Acme Corp crashed after 2 hours, the logs showed a 92 % drop in relevance caused by a pure‑vector store that couldn’t resolve relational queries.

Why Pure Vector Stores Fail on Relational Reasoning

The 0‑shot similarity trap

Vector stores excel at nearest‑neighbor look‑ups, but they treat every piece of text as a point in space. The moment a query needs to reason about how two entities relate, similarity alone falls apart. In our own experiments, a simple “upgrade my plan” request returned a vector match for the word upgrade but ignored that the user was on a Basic tier, so the bot suggested a Premium plan that the user could not legally purchase.

Case study: FAQ mismatch rates

We measured a real‑world FAQ bot over a 30‑day window. 78 % of query failures stem from missing relational context—the bot would fetch a passage that mentioned the same keyword but missed the surrounding clause that defined the relationship. The result was a mismatch rate that grew from 12 % to 84 % once the conversation crossed a single relational boundary.

“A billing‑inquiry bot returned the wrong plan details because it could only match the phrase ‘upgrade’ without understanding the user’s current tier.”

The lesson is clear: dense embeddings are blind to edges. If you need to ask “who reports to whom?” or “what prerequisite does this API have?”, a vector store alone will hallucinate.

Graph Stores Shine When Structure Matters

Edge‑weight decay

Graphs encode relationships as edges with weights that can decay over time, reflecting real‑world dynamics like employee turnover or contract expiry. In a pilot with a scheduling assistant, we attached a decay factor of 0.03 per week to reporting‑line edges. After two months, the assistant’s priority queue aligned with the actual org chart 96 % of the time, versus 71 % when we forced the same logic through a vector store.

Latency trade‑off

Graph traversals are not free. Graph traversal added an average of 187 ms per hop but reduced hallucinations by 42 %. For a typical three‑hop query (employee → manager → approver) the total added latency was ~560 ms, still acceptable for most internal tools where correctness outweighs raw speed.

A concrete win came from a scheduling assistant that leveraged a Neo4j knowledge graph of employee hierarchies. By consulting the graph, it correctly prioritized approvals, cutting missed‑deadline tickets from 14 to 3 per sprint. The same assistant, when run on a pure‑vector store, missed the hierarchy entirely and generated a backlog of 11 unresolved tickets each sprint.

Hybrid Architecture: The Best‑of‑Both Worlds

Vector‑first retrieval, graph‑second validation

The sweet spot is to let embeddings do the heavy lifting—pull the top‑k candidates in <10 ms—then feed those candidates into a graph filter that validates relational constraints. This pattern slashes token consumption because the LLM only sees vetted snippets.

Hybrid pipelines achieve a 31 % lower token cost (≈$4,200 /mo saved on OpenAI usage). In a travel‑planning bot, the hybrid flow fetched destination embeddings, then ran a Cypher query against an airline‑alliance graph. The result: 5 out of 6 impossible itineraries (e.g., “fly from JFK to LHR via a carrier that doesn’t serve the route”) were eliminated before the LLM ever saw them.

Cache‑aware routing

We built a simple in‑memory cache keyed by graph‑validated entity IDs. When the same entity appears in subsequent queries, we skip the graph step entirely. The cache hit rate settled at ~68 %, delivering sub‑20 ms end‑to‑end latency on 95 % of requests.

Our hybrid approach is not theoretical. After rolling it out on a production‑grade chatbot at a fintech startup, the team reported a 4.3× reduction in post‑release bugs related to memory misuse—the graph layer caught inconsistent state before it could corrupt the LLM’s context window, similar to what we documented in our voice agent platform.

Implementing the Hybrid Pattern in LangChain

Custom Retriever wrapper

LangChain makes it easy to compose retrievers. Below is a minimal HybridRetriever that wraps a PineconeRetriever and a Neo4jRetriever, similar to what we documented in our agent ops in production. The filter_by_relationship method runs a Cypher query on the top‑k vectors and returns only those that satisfy the relationship predicate.

from langchain.schema import Document
from langchain.retrievers import BaseRetriever
from pinecone import PineconeClient
from neo4j import GraphDatabase
from typing import List

class HybridRetriever(BaseRetriever):
    def __init__(
        self,
        pinecone_index: str,
        neo4j_uri: str,
        neo4j_user: str,
        neo4j_password: str,
        top_k: int = 10,
    ):
        self.pinecone = PineconeClient().Index(pinecone_index)
        self.neo4j_driver = GraphDatabase.driver(
            neo4j_uri, auth=(neo4j_user, neo4j_password)
        )
        self.top_k = top_k

    def _pinecone_search(self, query: str) -> List[Document]:
        resp = self.pinecone.query(
            vector=self._embed(query), top_k=self.top_k, include_metadata=True
        )
        return [
            Document(page_content=match["metadata"]["text"], metadata=match["metadata"])
            for match in resp["matches"]
        ]

    def _embed(self, text: str):
        # placeholder for your embedding model
        ...

    def filter_by_relationship(self, docs: List[Document], rel: str) -> List[Document]:
        ids = [doc.metadata["id"] for doc in docs]
        cypher = f"""
        MATCH (n) WHERE n.id IN $ids
        MATCH (n)-[r:{rel}]->(m)
        RETURN n.id AS id
        """
        with self.neo4j_driver.session() as session:
            result = session.run(cypher, ids=ids)
            valid_ids = {record["id"] for record in result}
        return [doc for doc in docs if doc.metadata["id"] in valid_ids]

    def get_relevant_documents(self, query: str) -> List[Document]:
        # vector‑first
        candidates = self._pinecone_search(query)
        # graph‑second validation
        validated = self.filter_by_relationship(candidates, rel="ALLOWED_WITH")
        return validated

The wrapper adds ≈28 ms overhead per request but improves answer correctness from 68 % to 91 % on our internal test suite. The code is deliberately lightweight; you can swap Pinecone for any dense vector DB and Neo4j for another property graph without changing the public interface.

Dynamic fallback logic

In production we sometimes see the graph return an empty set (e.g., new entities not yet ingested). The pattern we use is:

1. Run vector‑first retrieval.
2. Attempt graph validation.
3. If the filtered list is empty, fall back to the raw vector results but flag the response for human review.

This fallback kept the SLA under 1 s even when the graph was temporarily unavailable, and it prevented the bot from outright failing.

Operational Costs & Scaling Considerations

Cold‑start latency

Cold starts are dominated by the graph driver spin‑up. With Neo4j’s bolt protocol, the first request adds ~120 ms; subsequent requests settle at ~30 ms. Warm‑up scripts that issue a trivial Cypher query every 30 seconds keep the connection hot with negligible CPU impact.

Storage footprint

Running both stores costs ~12 % more RAM (2.4 GB vs 2.1 GB per 1 M docs) but yields 2× higher QPS under load. The extra RAM comes from maintaining adjacency lists and edge properties alongside vector indices. In a micro‑service container we allocated 4 GB total, leaving headroom for the LLM inference cache.

During a product launch, the hybrid stack sustained 1,200 RPS while a vector‑only stack throttled at 620 RPS. The graph layer’s ability to prune irrelevant candidates reduced the downstream token load, allowing the LLM to stay within its rate limits.

When to Stick with One, When to Blend

Low‑complexity domains

If your knowledge base consists of isolated facts—think a legal‑doc summarizer where clauses rarely reference each other—a pure vector store is sufficient. The overhead of a graph doesn’t pay off, and you avoid the extra operational surface.

High‑interdependency workloads

Conversely, any domain where entities are tightly coupled—policy compliance engines, recommendation systems with prerequisite chains, or multi‑step workflow orchestrators—benefits from a graph. The relational checks act as a safety net that prevents the LLM from constructing impossible or illegal outputs.

Teams that adopted hybrid early saw a 4.3× reduction in post‑release bugs related to memory misuse. One of our partners, a compliance platform built on top of the agentic stack described at https://agentic-whatsup.com, reported that the hybrid design shaved weeks off their QA cycle because the graph caught edge‑case rule violations before they reached production.

In practice we recommend a decision matrix:

After 6 months of running this in production at our voice agent platform, we hit the same issue with a pure‑vector design and switched to hybrid, seeing the token‑cost savings mentioned earlier.

If you’re still on the fence, try a quick A/B test: route 10 % of traffic through a graph‑validated path and compare hallucination rates. The data usually tells the story within a few days.

If you want your agents to reason reliably at scale, pair dense embeddings with a lightweight graph layer now—otherwise you’ll pay 3× the token bill and still get 40 % more errors — see our AI compliance work for the full breakdown.

Most AI products today are impressive in demos.

But the moment they hit production:

• workflows break
• context fails
• hallucinations appear
• costs explode
• observability disappears

The AI industry does not really have an “intelligence” problem anymore.

It has an infrastructure problem.

For the last two years, the ecosystem focused heavily on:

• chat interfaces
• prompt engineering
• copilots
• wrappers around foundation models
• “AI-powered” product features

That phase accelerated adoption.

But the market is now entering a different stage.

The hard problem is no longer:

“Can AI generate something useful?”

The hard problem is:

“Can AI systems operate reliably in real production environments?”

And that is where the next major opportunity is emerging.

The Demo Problem

Most AI demos look incredible.

They can:

• generate code
• summarize documents
• automate workflows
• answer questions
• orchestrate tasks

But production environments expose a completely different reality.

Once real users, real workflows, and real operational constraints enter the system, problems begin to appear:

• hallucinations
• fragile context handling
• inconsistent outputs
• broken execution chains
• runaway costs
• poor observability
• unsafe automation
• missing governance
• unpredictable agent behavior

This is why so many AI pilots never move beyond experimentation.

The market today is filled with:

• AI interfaces
• AI assistants
• AI wrappers
• AI copilots

But what enterprises actually need are:

• reliable systems
• operational controls
• execution runtimes
• observability layers
• governance infrastructure
• context orchestration

That is the real bottleneck now.

AI Systems Need a New Production Stack

Traditional software engineering was built around deterministic systems.

AI systems are different.

They are:

• probabilistic
• context-sensitive
• state-fragile
• operationally unpredictable

That means traditional software patterns are no longer enough.

AI requires an entirely new operational layer.

This feels very similar to earlier infrastructure shifts:

• Kubernetes standardized container orchestration
• Datadog transformed observability
• Stripe simplified payment infrastructure
• Temporal improved workflow reliability

AI is now reaching a similar stage.

The next generation of products will not just be AI applications.

They will be:

AI production infrastructure platforms.

The Real Layers of a Production-Grade AI System

Most discussions about AI still focus only on models.

But production-grade AI systems require much more than a model.

Below are the infrastructure layers that are becoming increasingly important.

1. Context Engineering

This is becoming one of the most critical areas in AI engineering.

Most AI systems fail not because the model is weak, but because the context is poor.

Production systems need to manage:

• historical memory
• workflow state
• user intent
• permissions
• business logic
• external data
• codebase understanding
• semantic relationships

This goes far beyond basic RAG.

The future belongs to systems that can dynamically assemble the right context at the right moment.

Prompt engineering is becoming commoditized.

Context engineering is becoming the moat.

2. Agent Execution Runtime

Most AI agents today are unreliable because they lack execution infrastructure.

A production runtime needs:

• retries
• rollback support
• checkpoints
• workflow state tracking
• timeout handling
• safe execution paths
• human approval systems

Without this, AI workflows become fragile very quickly.

The market does not just need agents.

It needs:

workflow infrastructure for AI systems.

3. Observability for AI Systems

Debugging traditional software is already difficult.

Debugging AI systems is significantly harder.

Production AI requires visibility into:

• prompts
• memory retrieval
• tool calls
• reasoning chains
• execution paths
• token usage
• latency
• hallucination patterns
• workflow failures

Most current systems still operate like black boxes.

This creates a massive opportunity for:

• AI observability
• AgentOps
• runtime tracing
• execution replay
• quality monitoring

The industry will likely see a:

“Datadog for AI systems”

category emerge.

4. Governance and Safety

As AI systems become more autonomous, governance becomes mandatory.

Enterprises need:

• approval workflows
• audit trails
• permission systems
• policy enforcement
• data isolation
• secure execution environments

Without operational controls, companies will struggle to trust autonomous systems at scale.

This becomes especially important in:

• healthcare
• finance
• enterprise automation
• internal copilots
• operational workflows

Governance is no longer optional infrastructure.

It is foundational infrastructure.

5. Evaluation and Reliability Testing

One of the biggest problems in AI today is silent degradation.

An AI workflow may work perfectly today and fail tomorrow because of:

• model updates
• prompt changes
• retrieval drift
• API schema changes
• edge cases
• workflow changes

That means AI systems need continuous evaluation.

Production-grade AI requires:

• regression testing
• scenario simulation
• adversarial testing
• replay systems
• benchmark scoring
• workflow validation

This category is still massively underdeveloped.

Why Infrastructure Will Matter More Than Interfaces

The first AI wave rewarded:

• interfaces
• demos
• speed
• accessibility

The next AI wave will reward:

• reliability
• orchestration
• observability
• governance
• scalability
• operational maturity

That changes where the real value gets created.

The winning companies may not be the ones with the best chat interface.

They may be the ones building:

• context runtimes
• orchestration layers
• observability platforms
• execution infrastructure
• repo intelligence systems
• AI governance tooling

The real opportunity is shifting downward into the infrastructure layer.

Repo Intelligence Might Become a Major Category

One particularly interesting opportunity is repo intelligence.

Current AI coding tools can generate code.

But they often lack:

• architectural understanding
• dependency awareness
• service relationships
• domain knowledge
• operational context

That creates problems in large production codebases.

A smarter system would:

• scan repositories
• understand architecture
• build dependency graphs
• map services
• infer business domains
• track workflows
• generate contextual intelligence for AI systems

This could dramatically improve:

• AI coding reliability
• automated refactoring
• debugging
• onboarding
• workflow automation

The future of AI-assisted engineering may depend heavily on systems that deeply understand software architecture.

What This Means for Builders

If you are building in AI today, this shift matters.

The market is getting saturated with:

• wrappers
• chat interfaces
• generic copilots
• shallow automation tools

But infrastructure gaps are still massively underbuilt.

That means opportunities are emerging in:

• context orchestration
• observability
• evaluation systems
• governance tooling
• repo intelligence
• workflow runtimes
• execution reliability

The next major AI products may come from engineering pain, not prompt creativity.

The Market Is Moving from Apps to Systems

This is the transition happening right now.

We are moving from:

• AI apps → AI infrastructure
• prompts → context systems
• copilots → execution runtimes
• experimentation → operational maturity
• wrappers → production platforms

The companies that win in AI will likely be the ones that solve:

• reliability
• orchestration
• observability
• governance
• context management
• execution safety

Not just generation.

The biggest AI companies of the next decade may not even look like AI companies.

They may look like infrastructure companies.

Final Thoughts

AI will absolutely transform software.

But models alone are not enough.

The next major challenge is building systems that AI can operate inside reliably.

That means:

• better infrastructure
• better orchestration
• better context systems
• better observability
• better governance
• better operational tooling

The future of AI does not belong only to model providers.

It also belongs to the companies building the operational layer around those models.

And that may become one of the biggest infrastructure opportunities of the next decade.