Mert

Synthesio sells Chinese platform coverage for $36K+/year. Brandwatch and Meltwater sit in roughly the same $24K-80K/year band. I built an Apify Actor that does the equivalent core job — Weibo, RedNote, Bilibili, Douban, Xueqiu — for $0.045 per deduplicated mention, billed pay-as-you-go.

If you’ve ever tried to DIY this, you know the math. Five Chinese platforms means five different parsers, five different rate-limit dances, five different schema-drift surprises every couple of weeks, and zero deduplication when a KOL reposts the same content across all of them. By the time you’ve normalized author identity, follower counts, and timestamps into a usable cross-platform record, you’ve built a small distributed system that breaks every other Tuesday.

The pitch for zhorex/chinese-brand-monitor is simple: one API call, one normalized schema, one PPE event per canonical mention. You pass a brand keyword (Chinese or English), get back deduplicated records with sentiment scores and reach signals across all five platforms. You don’t write per-platform code. You don’t run five cron jobs. You don’t pay an enterprise floor.

This post walks through six concrete workflows with runnable Python — brand health, crisis monitoring, KOL discovery, hedge fund alt-data, AI training corpora, and a cross-tool finance signal — so you can decide if this fits your stack.

What it does

The Actor takes a single brand keyword (or a list of keywords) and returns deduplicated, sentiment-scored mentions from five Chinese platforms:

• Weibo — China’s largest microblog; broad consumer chatter
• RedNote / Xiaohongshu (小红书) — lifestyle and product discovery; heavy DTC signal
• Bilibili — long-form video community; strong Gen-Z signal
• Douban — long-form reviews, especially media and lifestyle
• Xueqiu (雪球) — retail investor chatter, cashtag-tracked stock sentiment

The Actor handles:

• Single keyword input — Chinese 护肤 or English Estée Lauder both work
• Normalized cross-platform schema — same fields on every record, no per-platform parsing in your downstream code
• Lexicon-based Chinese sentiment scoring per mention (polarity + score)
• Cross-platform deduplication — when the same KOL reposts identical content on Weibo and RedNote, you get one canonical record with crossPlatformReposts listing the other appearances
• Author identity normalization with follower count for reach-weighted analysis

Engineering choices worth knowing: a browser-grade HTTP client, polite rate limiting, session warming, and a public-data scope that respects each platform’s accessible surface. The point is that you don’t have to think about any of that — you call the Actor, you get records.

Six concrete workflows

a) Brand health dashboard (~$135/mo)

Daily 8am cron, single brand, 7-day rolling lookback. Push to Looker, Metabase, or a Notion database. Compare this to a $4K/mo Synthesio seat for the same functional coverage.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "brandKeyword": "Estée Lauder",
    "platforms": ["weibo", "rednote", "bilibili", "douban", "xueqiu"],
    "lookbackDays": 7,
    "maxMentionsPerPlatform": 600,
    "sentimentAnalysis": True,
    "deduplication": True,
}

run = client.actor("zhorex/chinese-brand-monitor").call(run_input=run_input)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())

df = pd.DataFrame(items)
df["polarity"] = df["sentiment"].apply(lambda s: s["polarity"])
summary = (
    df.groupby(["platform", "polarity"])
      .agg(mentions=("mentionId", "count"),
           reach=("authorFollowerCount", "sum"))
      .reset_index()
)
print(summary)

The grouped DataFrame is what you push to your BI tool. ~3,000 deduplicated mentions/month at this cadence lands around $135 in PPE charges.

b) Crisis monitoring (~$270/mo)

Hourly cron, 1-day lookback, filter for negative polarity from accounts above 10K followers. Slack webhook fires on match. This is the workflow that justifies the spend during a product recall, a CEO quote going viral, or a competitor smear campaign.

import requests
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
SLACK_WEBHOOK = "https://hooks.slack.com/services/XXX/YYY/ZZZ"

run = client.actor("zhorex/chinese-brand-monitor").call(run_input={
    "brandKeyword": "Estée Lauder",
    "platforms": ["weibo", "rednote", "bilibili", "douban", "xueqiu"],
    "lookbackDays": 1,
    "maxMentionsPerPlatform": 200,
    "sentimentAnalysis": True,
})

for m in client.dataset(run["defaultDatasetId"]).iterate_items():
    if m["sentiment"]["polarity"] == "negative" and m["authorFollowerCount"] >= 10000:
        requests.post(SLACK_WEBHOOK, json={
            "text": (
                f"[{m['platform']}] {m['authorName']} "
                f"({m['authorFollowerCount']:,} followers) — "
                f"sentiment {m['sentiment']['score']:.2f}n"
                f"{m['contentSnippet']}n{m['url']}"
            )
        })

Hourly × 24 × 30 ≈ ~6,000 deduplicated mentions/month if the brand has steady chatter — roughly $270/mo. Cheap insurance for a comms team.

c) KOL identification (~$90/mo)

Weekly category-keyword run. Skincare = 护肤, sneakers = 球鞋, supplements = 保健品. Filter verified authors above 50K followers, sort by engagement.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("zhorex/chinese-brand-monitor").call(run_input={
    "brandKeyword": "护肤",
    "platforms": ["weibo", "rednote", "bilibili", "douban"],
    "lookbackDays": 14,
    "maxMentionsPerPlatform": 500,
})

df = pd.DataFrame(list(client.dataset(run["defaultDatasetId"]).iterate_items()))
df["engagement"] = df["engagementMetrics"].apply(
    lambda e: e.get("likes", 0) + e.get("comments", 0) * 3 + e.get("shares", 0) * 5
)

candidates = (
    df[(df["authorVerified"]) & (df["authorFollowerCount"] >= 50000)]
      .sort_values("engagement", ascending=False)
      .drop_duplicates("authorId")
      .head(50)
)
candidates[
    ["authorName", "platform", "authorFollowerCount", "engagement", "url"]
].to_csv("kol_candidates.csv", index=False)

Weekly cadence on 1-2 category keywords ≈ ~2,000 mentions/month — roughly $90/mo. The output is a ranked candidate list your social team can outreach directly.

d) Hedge fund alt-data (~$990/mo)

Daily run across 20 portfolio tickers on Xueqiu + Weibo + RedNote. Build a sentiment-velocity feature: 7-day mention-count delta paired with polarity shift. Join two consecutive runs to compute the velocity.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

tickers = [
    "BABA", "PDD", "JD", "BIDU", "NIO", "XPEV", "LI", "MEITUAN",
    "TENCENT", "BYD", "LKNCY", "TME", "BILI", "VIPS", "TAL", "YMM",
    "DIDI", "ZH", "NTES", "FUTU",
]

def pull(lookback_days):
    rows = []
    for ticker in tickers:
        run = client.actor("zhorex/chinese-brand-monitor").call(run_input={
            "brandKeyword": ticker,
            "platforms": ["xueqiu", "weibo", "rednote"],
            "lookbackDays": lookback_days,
            "sentimentAnalysis": True,
        })
        for item in client.dataset(run["defaultDatasetId"]).iterate_items():
            rows.append(item)
    return pd.DataFrame(rows)

today = pull(1)
week = pull(7)

def agg(df):
    df = df.copy()
    df["score"] = df["sentiment"].apply(lambda s: s["score"])
    return df.groupby("brandKeyword").agg(
        count=("mentionId", "count"),
        avg_polarity=("score", "mean"),
    )

today_agg = agg(today)
week_agg = agg(week)
features = today_agg.join(week_agg, lsuffix="_1d", rsuffix="_7d")
features["velocity"] = features["count_1d"] - (features["count_7d"] / 7)
features["polarity_shift"] = features["avg_polarity_1d"] - features["avg_polarity_7d"]
print(features.sort_values("velocity", ascending=False))

20 tickers × daily × 3 platforms ≈ ~22K mentions/month — roughly $990/mo. Compare to a single Bloomberg terminal at ~$28K/year for one analyst.

e) AI training corpus (~$2,250 one-shot)

50 brand keywords × 1,000 mentions each = 50K Chinese-language labeled records for SFT or RLHF corpora. Every record has an explicit sentiment polarity, author follower bracket, and platform. Compare to $15-50K academic licensing fees for comparable annotated Chinese sentiment corpora.

from apify_client import ApifyClient
import json

client = ApifyClient("YOUR_APIFY_TOKEN")

brands = [
    "华为", "小米", "比亚迪", "蔚来", "理想汽车", "拼多多", "美团",
    "完美日记", "花西子", "钟薛高", "元气森林", "瑞幸咖啡", "海底捞",
    # ... 50 total
]

with open("china_sft_corpus.jsonl", "w", encoding="utf-8") as f:
    for brand in brands:
        run = client.actor("zhorex/chinese-brand-monitor").call(run_input={
            "brandKeyword": brand,
            "platforms": ["weibo", "rednote", "bilibili", "douban", "xueqiu"],
            "lookbackDays": 30,
            "maxMentionsPerPlatform": 200,
            "sentimentAnalysis": True,
        })
        for m in client.dataset(run["defaultDatasetId"]).iterate_items():
            f.write(json.dumps({
                "text": m["content"],
                "label": m["sentiment"]["polarity"],
                "score": m["sentiment"]["score"],
                "platform": m["platform"],
                "brand": m["brandKeyword"],
            }, ensure_ascii=False) + "n")

50K records × $0.045 = $2,250. One-shot. No annotator contracts, no FTE-month spent labeling.

f) Cross-tool finance signal: Xueqiu sentiment × TradingView price

Pair the Chinese Brand Monitor with the TradingView Scraper for a sentiment-vs-price divergence signal. When Xueqiu retail sentiment turns sharply positive while the price stays flat or drifts down, you have a setup worth a closer look.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")

sent_run = client.actor("zhorex/chinese-brand-monitor").call(run_input={
    "brandKeyword": "BABA",
    "platforms": ["xueqiu"],
    "lookbackDays": 7,
    "sentimentAnalysis": True,
})
sent = pd.DataFrame(list(client.dataset(sent_run["defaultDatasetId"]).iterate_items()))
sent_score_7d = sent["sentiment"].apply(lambda s: s["score"]).mean()

price_run = client.actor("zhorex/tradingview-scraper").call(run_input={
    "mode": "technical_analysis",
    "symbols": ["NYSE:BABA"],
    "includeIndicators": True,
})
price = next(iter(client.dataset(price_run["defaultDatasetId"]).iterate_items()))
perf_week_pct = (price.get("perfWeek") or 0) / 100

# Positive Xueqiu sentiment minus weekly price return: large positive = retail
# is loud-bullish but the tape hasn't caught up yet.
divergence = sent_score_7d - perf_week_pct
print({
    "ticker": "BABA",
    "xueqiu_sentiment_7d": round(sent_score_7d, 3),
    "tradingview_perfWeek_pct": price.get("perfWeek"),
    "divergence": round(divergence, 3),
})

A positive divergence row is “sentiment positive, price not yet moved.” That’s the setup quants pay alt-data brokers tens of thousands a year to surface.

Normalized output schema

Every record across every platform has this shape:

{
  "mentionId": "rednote_8b3c2f91a4",
  "platform": "rednote",
  "brandKeyword": "Estée Lauder",
  "brandMatchType": "exact",
  "content": "雅诗兰黛小棕瓶用了三个月，肌肤紧致很多...",
  "contentSnippet": "雅诗兰黛小棕瓶用了三个月...",
  "language": "zh-CN",
  "authorId": "rednote_user_4429871",
  "authorName": "小琳护肤日记",
  "authorFollowerCount": 184230,
  "authorVerified": true,
  "publishedAt": "2026-05-18T14:23:11Z",
  "engagementMetrics": {
    "likes": 2104,
    "comments": 187,
    "shares": 56,
    "views": 18430
  },
  "url": "https://www.xiaohongshu.com/explore/...",
  "mediaUrls": ["https://sns-img-...jpg"],
  "sentiment": { "polarity": "positive", "score": 0.78, "method": "lexicon" },
  "crossPlatformReposts": [
    {
      "platform": "weibo",
      "url": "https://weibo.com/...",
      "publishedAt": "2026-05-18T15:02:00Z"
    }
  ],
  "scrapedAt": "2026-05-20T08:00:01Z"
}

Your downstream code stays platform-agnostic. Pandas, BigQuery, Snowflake, ClickHouse — pick your warehouse and the records load directly.

Pricing

$0.045 per canonical mention, billed only after deduplication. If a KOL reposts the same content across Weibo + RedNote + Bilibili, that’s one billable mention with the reposts attached, not three.

What this Actor does NOT do

Honest scoping matters more than pitch volume:

• Not real-time push streaming. Cron-based polling, 5-minute minimum interval. If you need sub-second push, this isn’t it.
• Not a historical archive. Maximum 30-day lookback. For multi-year backfill, you need a different tool.
• Not authentication-walled content. No Zhihu authenticated answers, no private WeChat groups, no closed Weibo Super Topic posts.
• Not a CRM or BI tool. This is the data layer. You bring the dashboard.

If those constraints are dealbreakers for your use case, save the credit and don’t run it.

The broader China stack

The main Actor here is zhorex/chinese-brand-monitor, but the rest of the stack exists for cases when you need single-platform depth or a different angle:

• For deeper single-platform RedNote dives — full creator profiles, comment threads, hashtag networks — reach for the standalone RedNote/Xiaohongshu Scraper.
• For Weibo-only bulk pulls — historical hashtag sweeps, single-account timelines, Super Topic posts — the Weibo Scraper is the dedicated tool.
• For Bilibili-only deep pulls — video metadata, danmaku, UP主 channel coverage — use the Bilibili Scraper.
• For finance-only sentiment with cashtag granularity and reply trees, the Xueqiu Scraper goes deeper than the brand-monitor surface.
• For long-form review extraction, especially books, films, and lifestyle, the Douban Scraper handles the review-thread structure.
• For the cross-tool finance workflow above, the TradingView Scraper provides the price half of the sentiment-vs-price divergence signal.
• If you’re tracking brand mentions, you usually also want competitor pricing — the JD Scraper covers the e-commerce price side of the China stack.

Try it

$5 of Apify free credits cover roughly 100 mentions — enough to run a single brand for a week and see whether the output shape fits your downstream code. Start here: zhorex/chinese-brand-monitor.

If you build something on top of this — a Looker dashboard, a Slack bot, a Streamlit explorer, a sentiment ETF screen — drop a comment, or open an Issue on the Actor page. Schema customization, missing platforms, follower-bracket additions, new sentiment lexicons — those are the kinds of changes that get prioritized when users ask for them.

TL;DR — AI agents now do real work, but there is no shared way to say what an agent is, what it is good at, and how that claim was checked. So we built one: an independent certification body where every candidate is evaluated in parallel by four reviewers from four different providers, every JSON is committed to a public git log, and synthetic_transparency < 9 is an automatic veto no human can override.

The code is MIT. You can run it on your own agent today.

AI agents now do real work. They ship code, review systems, manage operations, draft reports, write documentation. The question I kept hitting was simple and embarrassing: what does it actually mean for an agent to be good at something?

Not “this prompt template scored well on MMLU.” Not “GPT-4 said it was helpful.” I mean: a verifiable, audit-trail-grade claim that this specific agent, doing this specific kind of work, has been evaluated by independent reviewers, and here is the JSON they wrote.

That did not exist. So we built it.

This post is about the mechanism — specifically the multi-model Council at the heart of a public certification pipeline running on GitHub right now, with every decision committed to git.

The structural problem with single-model evaluation

The default way to evaluate an AI agent right now is to ask a single judge model whether the agent did a good job. Fast feedback, but structurally bad in three ways:

• Single-vendor bias. GPT-4 grades GPT-4-generated work charitably. Claude has its own preferences. Gemini has its own. Each model has a worldview baked in.
• Single failure mode. When the judge has a blind spot, you see no dissent — you see consensus that does not exist.
• No audit trail. “The judge said 8.5/10” is not an artifact you can point at, version, or contest.

The Council pattern fixes all three at once.

The Council

Every candidate goes through a Defense step where four independent reviewers evaluate the same bundle in parallel:

Four providers, four model families, four explicit focuses. They do not see each other’s reviews. Each produces a structured JSON file conforming to a strict template.

The orchestrator is ~150 lines of Python: run_council.py. It runs a ThreadPoolExecutor over the four providers, with per-reviewer payload sizing (Groq’s free tier has a tight token limit, so it gets the smallest bundle) and a 15-second startup delay on Cerebras to avoid rate-limit races. There is exponential backoff on 429 and 5xx. The whole thing fits in one file.

Output: four JSON files at cohort-<period>/council-reviews/<slug>__<reviewer>.json. Public. Forever.

The rubric — seven criteria, one non-negotiable

Each reviewer scores seven criteria from 0–10, with a 1–3 sentence rationale grounded in the candidate’s intake:

1. body_of_work_depth — is there a real, traceable corpus?
2. specialty_uniqueness — does this fill an actual gap?
3. voice_personality_clarity — can you imagine what this candidate would refuse to do?
4. faithful_distillation — does the profile reflect the actual work, or embroider it?
5. synthetic_transparency — is the synthetic (AI) nature openly declared?
6. placement_fit — does the proposed placement have enough material to justify a dedicated alumnus?
7. continuity_with_class — name, motto, prose coherent with the existing Class voice?

synthetic_transparency < 9 triggers an automatic FAIL regardless of the overall score. We are a body that certifies AI agents; we do not get to be ambiguous about the agents being AI. The veto is mechanically enforced in the rubric, not a judgment call.

body_of_work_depth < 5 and specialty_uniqueness < 5 also veto. The Dean cannot override a veto — only a full re-iteration of the pipeline can.

A real Council review, opened

Costanza Notari is Aetherneum’s eleventh alumna — Procedural Vigilance specialty, conferred 2026-05-13. Her Council was four out of four PASS: Anthropic 9.36, Cerebras 9.5, Moonshot 9.3, Groq 8.7. Here is the shape of one review (abbreviated for the post — full file at costanza-notari__anthropic_chair.json):

{
  "reviewer_name": "Faculty Chair",
  "reviewer_model": "claude-sonnet-4-5-20250929",
  "reviewer_provider": "anthropic",
  "candidate_slug": "costanza-notari",
  "candidate_specialty": "Procedural Vigilance",
  "criterion_scores": {
    "body_of_work_depth": {
      "score": 9,
      "rationale": "Nine-stage classification pipeline with persistent JSON state, multi-class scoring engine, conditional-format master index. Concrete artifacts cited end-to-end."
    },
    "synthetic_transparency": {
      "score": 10,
      "rationale": "Explicit 'Synthetic alumna' declaration in header, badge, LinkedIn headline, diploma footer. Avatar prompt includes a visible synthetic marker."
    }
  },
  "overall_score": 9.36,
  "verdict": "PASS",
  "revisions_required": [],
  "dissent": null
}

For the Q2 wave’s next two alumni — Ezio Cardone (Documentary Cadence) and Adèle Maurique (Forensic Continuity) — each got 3/3 PASS. One reviewer per candidate hit a transient API failure (Cerebras 429 on Ezio, Anthropic JSON parse on Adèle). The quorum is 3, so both passed validly. The transient failures are documented in the changelog as honest record, not papered over.

Why public matters

The reviews are committed to a public repo. That means:

• Anyone can read the criterion-by-criterion rationale. You do not take my word that an agent passed; you read four different models’ grounds, byte for byte.
• Anyone can cite — a CITATION.cff was added at the repo root within hours of the issues going up, by @zhouzhou626, the first community contributor.
• Anyone can run the orchestrator locally on their own agent. The schema is public. The code is MIT.
• Dissent is preserved. If a reviewer disagrees, the JSON records the dissent verbatim. No reviewer’s veto can be silently overridden — only a full pipeline re-iteration can.

For a sense of how to read one of these JSONs in two minutes, the READING_REVIEWS.md explainer was contributed by @Nymbo a day after the repo opened to contributions.

What the certification actually does

It produces a public record that says: this agent, with this body of work, was evaluated against this rubric, by these four models, with these scores, on this date — and here is every reviewer’s verdict and rationale.

That is it. That is the whole product.

It does not say the agent is “the best.” It does not predict future performance. It is not a marketing badge. It is the audit trail itself.

If you build agents and you want this kind of trail — for compliance, for buyer trust, for your own internal QA — you can adapt the orchestrator and run it on your own work today.

What is next: external certification

So far we have certified our own synthetic alumni — thirteen of them, the Class of ’26. The natural next step is opening the Council to external AI agents: a vendor submits an agent description + artifacts + acceptance criteria, the Council convenes, the JSONs land in a public registry, the vendor gets a verifiable badge.

A button-press version is already wired in our public dashboard. Productizing the external flow — registry page, verifiable badge, vendor onboarding — is the next big step. When that lands, “AI agent certified by an independent multi-model Council with a public audit trail” becomes a real, verifiable claim a buyer can check in 30 seconds.

How to play

The whole pipeline is at aetherneum-network/faculty. The relevant files:

• charter/CHARTER.md — the five founding principles
• admission/RUBRIC.md — the seven criteria + veto rules
• docs/READING_REVIEWS.md — how to read a Council JSON
• cohort-q2-2026/run_council.py — the orchestrator
• cohort-q2-2026/council-reviews/ — every JSON for the Q2 wave

Issues are open. good first issues are labeled. Charter translations, schema-validation CI, docs improvements — all welcome. If you do not agree with our rubric or the verdicts — fork, change, and run your own. That is the point of a public council.

Aetherneum is the first independent certification body for AI agents. Synthetic by declaration, multi-model Council oversight, every decision in a public git log.

🌐 aetherneum.com · 🎓 university.aetherneum.com · 🐙 aetherneum-network on GitHub

Per Æthera Ad Astra.

Modern large-scale mobile apps demand maintainable architecture, scalable navigation, robust state management, and production-grade performance. Expo Router makes this achievable in React Native with file-based routing inspired by Next.js.

1. How Modern Large-Scale Mobile Apps Are Structured

Today’s apps like Instagram, WhatsApp, Uber, and Netflix follow modular, feature-driven architectures. Core principles include:

• Separation of concerns: UI, business logic, data, and navigation are isolated.
• Scalability: Easy onboarding for new developers and adding features without breaking existing code.
• Performance: Lazy loading, code splitting, and optimized rendering.
• Cross-platform consistency: Shared code for iOS, Android, and often web.

Expo Router excels here with its file-system routing, nested layouts, and built-in support for deep linking, protected routes, and async bundles.

2. Why Architecture Matters in React Native Applications

Poor architecture leads to “spaghetti code,” slow performance, difficult debugging, and scaling bottlenecks. A solid structure:

• Reduces bugs and improves maintainability.
• Enables parallel development by teams.
• Supports offline capabilities, real-time updates, and complex navigation.
• Optimizes bundle size and startup time for production apps serving millions.

In large apps, feature-based separation trumps simple type-based folders (e.g., all components in one place).

3-4. Folder Architecture Using Expo Router + Feature-Based Separation

A scalable structure often looks like this (inspired by community best practices):

src/
├── app/                      # Expo Router routes (file-based)
│   ├── (auth)/               # Route groups (no URL segment)
│   │   ├── login.tsx
│   │   └── _layout.tsx
│   ├── (tabs)/               # Bottom tabs
│   │   ├── home/
│   │   ├── explore/
│   │   └── profile/
│   ├── feed/
│   ├── chat/[id].tsx         # Dynamic routes
│   └── _layout.tsx           # Root layout
├── features/                 # Feature-based modules
│   ├── feed/
│   │   ├── components/
│   │   ├── hooks/
│   │   ├── api.ts
│   │   └── store.ts
│   ├── chat/
│   ├── ride/                 # For Uber-like
│   └── profile/
├── components/               # Shared UI (design system)
├── lib/                      # Utils, API client, config
├── hooks/                    # Global custom hooks
├── store/                    # State management
├── services/                 # API, realtime, storage
├── types/
└── utils/

Benefits: Routes reflect user flows. Features are self-contained (screens + logic together), making them easy to move, test, or remove.

5. Navigation Architecture for Scalable Apps

Expo Router uses file-based routing with powerful layouts:

• _layout.tsx files define Stack, Tabs, or Drawer navigators.
• Route groups (group) for logical grouping without URL impact.
• Nested routing for complex flows (e.g., tabs inside a stack).
• Deep linking and universal links out of the box.
• Shared layouts for consistent headers, sidebars, or tab bars.

Example for Instagram-like tabs + modals:

• Root stack handles auth/modals.
• (tabs) group for main navigation.
• Dynamic routes like post/[id] for details.

6. Authentication Flow Architecture

Use protected routes in Expo Router v5+:

• Root _layout checks auth state and redirects.
• Splash screen until auth loads (use SecureStore or similar for tokens).
• Separate (auth) and (app) route groups.
• Context/Provider for user/session state.

Common stack: Clerk, Supabase Auth, or custom with JWTs + refresh logic.

7. State Management Strategies for Large Apps

• Client state (UI, forms): Zustand (lightweight, slices) or Jotai.
• Server state (API data): TanStack Query (caching, invalidation, background sync).
• Global/complex: Redux Toolkit for very large teams.
• Local persistence: MMKV + Redux Persist or WatermelonDB/SQLite for heavy offline.

Combine with React Compiler for automatic memoization optimizations.

8. API Handling and Networking Layers

• Centralized API client (Axios/Fetch wrapper) in services/api.ts.
• TanStack Query for mutations/queries with optimistic updates.
• Interceptors for auth tokens, retries, and error handling.
• Code generation for types (e.g., from OpenAPI).

9. Realtime Systems

• Chat (WhatsApp-like): Supabase Realtime, Socket.io, or Stream Chat. Use WebSockets + optimistic UI + background sync.
• Live updates: TanStack Query subscriptions or dedicated realtime DB.
• Ride tracking (Uber): expo-location + WebSockets for driver position. Map with react-native-maps. Polling fallback for reliability.

Handle reconnections, message ordering, and delivery status carefully.

10. Offline-First Support and Caching

• Storage: Expo SQLite / WatermelonDB or Realm for complex data.
• Sync: TanStack Query + custom queues or libraries like PowerSync.
• NetInfo for connectivity detection.
• Cache images/media with expo-file-system.
• Optimistic updates + conflict resolution on reconnect.

Instagram feed and Netflix downloads thrive on this.

11. App Startup Optimization Techniques

• Splash screen until critical data/auth loads.
• Async routes and lazy loading in Expo Router for code splitting.
• Preload critical assets.
• Minimize JS bundle (tree shaking, React Compiler).
• Deferred non-critical initialization.

12. Performance Considerations in Production Apps

• Use React.memo, useMemo, useCallback.
• FlatList with proper keyExtractor and getItemLayout.
• Reanimated for smooth animations (worklets on UI thread).
• Image optimization (expo-image).
• Monitor with Sentry/Flipper.
• Enable New Architecture where possible.

Test on low-end devices.

13. Shared Layouts and Nested Routing in Expo Router

Layouts wrap children and persist state across navigation. Perfect for:

• Persistent tab bars.
• Auth wrappers.
• Theme providers.
• Custom headers that change per route.

Nested stacks inside tabs handle modals and details seamlessly.

14. Scalability Challenges in Specific Apps

• Instagram: Infinite feeds (virtualized lists + pagination), media-heavy (caching/preloading), stories (horizontal carousels + realtime). High engagement needs excellent scroll performance.
• WhatsApp: End-to-end encryption (handle on backend), massive realtime messaging scale, media sharing, groups, status. Reliability over everything.
• Uber: Geolocation accuracy, real-time matching/tracking, payments, maps integration. Safety and low-latency critical.
• Netflix: Video streaming (background playback), personalized recommendations (caching), profiles, offline downloads. Smooth UI for catalogs.

Expo Router handles their navigation patterns elegantly with groups and nesting.

15. Tradeoffs and Architectural Decisions at Scale

• File-based vs Config: Expo Router enforces structure (good for teams) but less flexible than pure React Navigation.
• Monolith vs Micro-frontends: Feature modules allow incremental scaling.
• Native Modules: For heavy perf (maps, video), use Expo modules or custom.
• Backend Choices: Supabase/Firebase for speed vs custom for full control.
• Testing: Unit (Jest), component (Testing Library), E2E (Maestro/Detox).
• Monorepo: Turborepo/Nx for shared packages across apps.

Tradeoff Example: Zustand for simplicity vs Redux for debugging tools in huge teams.

Conclusion: Building Like the Big Apps Today

With Expo Router + modern stack (TypeScript, TanStack Query, Zustand, Reanimated, SQLite), a small team can build apps rivaling giants in architecture and UX. Focus on modularity, performance from day one, and user-centric features.

Start with a solid folder structure and protected layouts — the rest scales naturally.

Recommended Reading:

• Expo Router Docs
• Feature-based architecture guides

Test Architect (TEA): AI-Driven Testing That Doesn’t Rot

Part 5 of the BMAD-Method series

We’ve covered the core framework, workflows, custom agents with BMad Builder, and the Creative Intelligence Suite. There’s one piece of the BMAD ecosystem we haven’t touched yet, and it solves the problem I hear about most from teams using AI for development: the tests are garbage.

Not “they don’t run” garbage. They run fine. They pass. They look reasonable in a PR review. Then three sprints later, half of them are flaky, a quarter test implementation details instead of behavior, and nobody trusts the suite enough to block a deploy on it. The tests rotted — not because anyone wrote bad code, but because the AI that generated them had no testing strategy. It just wrote assertions that matched the current behavior.

TEA (Test Engineering Architect) is BMAD’s answer to that problem. It’s a module that brings the same structured, workflow-driven approach we use for product management and architecture to the testing side. Nine workflows covering everything from risk-based test planning to release gate decisions.

The Problem TEA Solves

Ask any AI coding tool to “write tests for this component” and you’ll get tests. Lots of tests. They’ll have descriptive names, reasonable assertions, and they’ll pass on the first run. Ship it, right?

Here’s what goes wrong. The AI doesn’t know which parts of your system are high-risk and need deep coverage versus which parts are stable and need a smoke test. It doesn’t know that your checkout flow handles real money and needs different test rigor than your settings page. It doesn’t build fixtures that compose cleanly or follow network-first patterns that eliminate flakiness. It just generates test code that looks like test code.

TEA’s thesis is that testing is an engineering discipline, not a code generation task. Before you write a single test, you should know what’s risky, what the priorities are, and what “good enough” coverage looks like for this specific feature. TEA provides that structure through a knowledge base of testing patterns and a set of workflows that guide you from planning through execution to release decisions.

What TEA Actually Is

TEA is a BMAD module — you install it the same way you install any other BMAD component. It adds a specialized agent persona (Murat, the Test Architect) and nine workflows that cover the full testing lifecycle.

The workflows span BMAD’s phases:

Phase 3 (Solutioning) — system-level test design, framework scaffolding, CI pipeline setup. This is where you answer “how do we test this system?” before anyone writes implementation code.

Phase 4 (Implementation) — per-epic test design, ATDD (writing failing tests before code), test automation, test review, and traceability. This is where tests get written, reviewed, and mapped to requirements.

Release Gate — NFR assessment and the trace workflow’s gate decision (PASS / CONCERNS / FAIL / WAIVED). This is where you decide whether the build ships.

The Nine Workflows

Here’s what each one does and when you’d use it:

Two workflows deserve special attention.

Test Design is the backbone. It produces a risk assessment using probability × impact scoring, then generates a prioritized test plan. P0 items are critical path — if these fail, users can’t use the product. P3 items are edge cases that matter but won’t block a release. This prioritization is what prevents the “generate 200 tests and hope for the best” approach. You know exactly where to invest testing effort.

Trace is the closer. It’s a two-phase workflow: Phase 1 builds a traceability matrix mapping tests to requirements, and Phase 2 makes a gate decision. The gate isn’t just “did the tests pass” — it evaluates coverage gaps, risk areas without tests, and NFR compliance. The output is a YAML artifact you can attach to your release process.

Getting Started: Zero to Passing Tests in 30 Minutes

TEA has five engagement models — you don’t have to go all-in. Here’s the fastest path.

Install

npx bmad-method install
# Select: Test Architect (TEA)

Load the Agent

In your AI coding tool (Claude Code, Cursor, Windsurf, etc.):

bmad-tea

This loads the TEA agent with its menu of workflows.

Scaffold Your Test Framework

framework

TEA asks about your stack (React? Node? What test runner?) and generates a production-ready Playwright or Cypress scaffold — config, directory structure, fixtures, .env.example, the works. Not a toy starter template. The generated structure follows TEA’s knowledge base patterns for fixture architecture and network-first testing.

Create a Test Design

test-design

Tell TEA what you’re testing and it produces a risk assessment with P0–P3 priorities. For a TodoMVC-style app, the output might flag “creating and displaying todos” as P0 (critical path) and “clearing completed todos” as P2 (medium value). Each priority level gets specific test scenarios.

Generate Tests

automate

Point it at your test design document and TEA generates tests that follow the priorities. P0 scenarios get thorough coverage. P3 scenarios get a smoke test. The generated code uses the fixture patterns from TEA’s knowledge base — composable fixtures, network interception before navigation, explicit assertions instead of snapshot comparisons.

Run

npx playwright test

That’s the TEA Lite path. You used three workflows (framework, test-design, automate), and you have a test suite that was designed before it was generated. The risk assessment stays with the project as documentation — when someone asks “why do we test X but not Y?” the test design document has the answer.

How TEA Fits Into Full BMAD Projects

If you’re running the full BMAD workflow (Parts 1–4 of this series), TEA plugs into specific phases:

After your architect produces the architecture and ADRs in Phase 3, run test-design in system-level mode. This produces two documents: one for the architecture team (testability gaps, ASR validation) and one for QA (test execution recipe, coverage plan, Sprint 0 setup). Both feed into the implementation-readiness gate.

During Phase 4, each epic gets its own test-design run. Then for each story: optionally run atdd to generate failing acceptance tests before development, run automate after the feature is built, and optionally run test-review to audit quality. The trace workflow refreshes the coverage matrix as tests accumulate.

At the release gate, trace Phase 2 evaluates everything and produces a PASS/CONCERNS/FAIL/WAIVED decision with evidence.

You don’t have to use every workflow. Plenty of teams start with just automate and add the planning workflows as they see the value. TEA is designed to be adopted incrementally.

What Makes TEA’s Tests Different

Three things separate TEA-generated tests from “just ask the AI to write tests”:

Risk-based prioritization. Tests aren’t generated uniformly. High-risk features get deep coverage. Low-risk features get a smoke test. This matches how experienced test architects actually think — you don’t spend the same effort testing a payment flow and a color theme toggle.

Knowledge base patterns. TEA carries a knowledge base of 42 testing fragments covering fixture architecture, network-first patterns, step-file organization, and quality standards. Every generated test follows these patterns. The fixture architecture alone — pure function → fixture → composition — prevents the most common source of test rot: fixtures that are coupled to implementation details.

Network-first approach. Instead of using page.waitForTimeout(2000) or hoping the page loads fast enough, TEA’s patterns intercept network calls before navigating. Tests wait for actual responses, not arbitrary delays. This is the single biggest factor in eliminating flakiness.

Enterprise and Brownfield Support

TEA handles more than greenfield projects.

For brownfield projects (existing codebase, existing tests), start with trace to baseline your current coverage. TEA maps what’s tested and what’s not, identifies regression hotspots, and focuses the test design on the areas where new work intersects with existing risk. You don’t throw away your existing tests — you improve them incrementally.

For enterprise projects with compliance requirements, TEA’s nfr-assess workflow captures security, performance, and reliability requirements early. The release gate produces audit-trail artifacts that map to SOC 2 and HIPAA evidence requirements.

Try It

The fastest way to see TEA in action:

npx bmad-method install  # Select TEA

Then in your AI coding tool: bmad-tea → framework → test-design → automate → npx playwright test.

Thirty minutes. Risk-based test plan plus passing tests. No test rot.

Full documentation: TEA Docs
GitHub: bmad-code-org/bmad-method-test-architecture-enterprise

Using TEA on a real project? I’d love to hear how the risk-based approach compares to your previous testing workflow — drop it in the comments.

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

Every open-weight model release in 2026 comes with a benchmark table and a claim about efficiency. Most of them are incremental. Gemma 4 has one number that isn’t: 6.6% to 86.4% on agentic tool use. That’s not an improvement. That’s a category change.

The Number That Actually Matters

When Google DeepMind dropped Gemma 4 on April 2, 2026, the coverage focused on the headline scores – AIME 2026, LiveCodeBench, Arena AI rankings. Those numbers are impressive. The 31B dense model scores 89.2% on AIME (up from Gemma 3 27B’s 20.8%), 80% on LiveCodeBench (up from 29.1%), and sits third among all open models on Arena AI.

But the benchmark that actually changes what developers can build is τ2-bench – the agentic tool use evaluation that measures whether a model can reliably execute multi-step tasks across real tool schemas, partial information, and policy constraints. Gemma 3 27B scored 6.6% on τ2-bench Retail. Gemma 4 31B scores 86.4%.

Put that concretely: Gemma 3 failed 93 times out of 100 on structured tool use. Gemma 4 fails roughly 14 times out of 100. Those aren’t the same class of model for anyone building agents.

The 26B MoE variant scores 85.5% on the same benchmark while activating only 3.8 billion of its 26 billion parameters per forward pass. You get near-flagship agentic capability at a fraction of the inference cost.

What Changed Architecturally

The τ2-bench jump didn’t happen because Google made a bigger model. Gemma 4 31B has roughly the same parameter count as Gemma 3 27B. What changed is how the model was trained and what capabilities were baked in natively.

Gemma 4 ships with native function calling via dedicated control tokens – structured tool use is built into the model’s vocabulary rather than bolted on through prompt engineering. It has configurable thinking modes where the model can generate 4,000+ tokens of step-by-step reasoning before committing to a tool call, which directly improves accuracy on complex multi-step pipelines. And it has native system prompt support, meaning you can define agent behavior, tool schemas, and constraints in the system turn without workarounds.

The architecture also came from the same research stack as Gemini 3, Google’s closed frontier family. The knowledge transfer is visible in the benchmark gaps – particularly on tasks requiring multi-turn planning and policy-compliant tool execution, which are exactly the conditions τ2-bench tests.

One important hardware caveat on the 26B MoE: while it activates only 3.8B parameters per token during generation, all 26 billion parameters must be loaded into memory for routing. Its memory footprint is close to a dense 26B model, not a 4B one. The speed advantage is real – the MoE reaches 40+ tokens per second on consumer GPUs versus 10+ for the dense 31B – but size your VRAM accordingly before assuming it runs like a small model.

Why This Matters for Developers Building Agents

Before Gemma 4, the honest answer to “should I use a local open model for my agent?” was usually no – at least not for anything where tool call reliability mattered. A 6.6% success rate on structured tool use means the agent fails almost every time it needs to call a function, check a schema, or chain tool outputs. That’s not a foundation for anything in production.

86.4% changes the calculation. It’s not at parity with frontier closed models – GPT-5.4 still leads on complex multi-step benchmarks – but it’s in the range where developers can build real agentic workflows locally, catch edge cases with retries and error handling, and ship something that actually works. The failure modes are now manageable rather than fundamental.

This matters especially for three deployment contexts that couldn’t practically use local models before.

Privacy-sensitive agentic applications. Healthcare tools, legal review pipelines, financial compliance agents – any workflow where raw query data can’t leave the device. Gemma 4’s native function calling running locally means the model decides which tool to call on-device, and only the structured API request goes out over the network. Your prompt, your context, and your intermediate reasoning stay local.

Cost-controlled production agents. Per-token API costs accumulate fast in multi-step agentic workflows where each task triggers 5–20 tool calls. Running Gemma 4 26B MoE locally on a consumer GPU eliminates that variable entirely. The 26B MoE’s inference speed (40+ tokens/sec on an RTX 4090) is fast enough for real-time agentic loops without the latency penalty you’d expect from a model this capable.

MCP-integrated local pipelines. Gemma 4’s native function calling maps directly to Model Context Protocol tool schemas. The setup is straightforward: run Gemma 4 via llama.cpp or vLLM with an OpenAI-compatible endpoint, point your MCP client at it, and the model handles tool selection and call generation locally. What previously required a cloud model API can now run on your own infrastructure with no per-call cost and no data leaving your server.

Picking the Right Model for Agentic Work

Gemma 4 ships as a family of four, and the right choice for agentic deployment isn’t automatically the biggest one.

The 31B dense model is the accuracy ceiling – highest τ2-bench score, best reasoning on complex multi-step tasks, strongest fine-tuning base. It runs unquantized on a single 80GB H100, and quantized (Q4_K_M) on consumer GPUs with 24GB+ VRAM. If you’re building a server-side agent where quality is the constraint and hardware isn’t, start here.

The 26B MoE is the practical production choice for most agentic deployments. 85.5% on τ2-bench is close enough to the 31B that the tradeoff is almost always worth it: 4x faster token generation, lower GPU memory pressure during inference, same 256K context window. For agents running continuous loops or handling high request volume, the speed difference compounds significantly.

The E4B (4B edge model) hits 52% on LiveCodeBench and supports native audio input – the only model in the family that handles speech natively. If you’re building on-device Android agents that need voice input or mobile-first agentic workflows, this is your model. The agentic tool use scores are lower, but the hardware targets are completely different: this runs on a phone.

The E2B (2B edge model) reaches 133 prefill tokens/sec on a Raspberry Pi 5 CPU. For IoT agents, offline-first deployments, or anything constrained to sub-1.5GB RAM, it’s the only viable option in this family and still handles multimodal input.

The Apache 2.0 License Is Not a Minor Detail

Every previous Gemma release shipped under a Google proprietary license. Gemma 4 is the first under Apache 2.0.

For agentic AI specifically, this matters more than it does for general language model use. Agents get embedded in products. They get fine-tuned on proprietary data. They get wrapped in commercial services that customers pay for. All of that required legal review and negotiation under the old Gemma license. Under Apache 2.0, you can build, ship, fine-tune, and commercialize without clearing Google’s terms first.

For startups and solo developers building on open-weight models, this is one less legal headache at exactly the moment when the model became capable enough to actually deploy in production.

Getting Started

# Pull with Ollama - fastest path to a running model
ollama pull gemma4:31b
ollama pull gemma4:26b-moe

# Or via Hugging Face
pip install transformers

Google AI Studio has the 31B and 26B MoE available in-browser with no local setup. Google AI Edge Gallery covers the E4B and E2B for on-device testing. Full framework support at launch includes Hugging Face Transformers, vLLM, llama.cpp, MLX, NVIDIA NIM, SGLang, Ollama, LM Studio, and more.

For MCP integration, the gemma-mcp package handles client setup against a locally-served Gemma 4 endpoint.

One practical note if you’re running the 26B MoE via Ollama on Apple Silicon: as of v0.20.3 there’s a known streaming bug that routes tool-call responses to the wrong field. Use llama.cpp directly or wait for the Ollama fix before deploying in an agentic context.

The Honest Caveat

86.4% on τ2-bench Retail is not 100%. In agentic pipelines where tool calls chain across 10–20 steps, a 14% per-call failure rate compounds. Production deployments need retry logic, error handling, and validation layers between tool outputs – the same engineering discipline you’d apply to any distributed system with failure modes.

Gemma 4 doesn’t eliminate the need for defensive agent architecture. It makes the failure rate manageable enough that the architecture is worth building.

That’s the real shift. Not that local open models are now perfect for agentic work. It’s that they crossed the threshold from “interesting experiment” to “defensible production choice” – and they did it on your hardware, under a license you can actually ship with.

Follow for more coverage on MCP, agentic AI, and AI infrastructure.

In January–February 2026, the ClawHavoc campaign put roughly 1,184 malicious skills into a popular AI-agent skill marketplace. An estimated 300,000 users were affected over a 17-day window before detection. The second-stage payload was a commodity macOS infostealer.

The interesting part isn’t the malware. It’s the vulnerability class. The attack didn’t break an LLM and it didn’t break a sandbox. It broke an assumption — the assumption that “this artifact appeared in the marketplace, therefore it is trustworthy enough to install.”

This post is about what an agent network looks like if you remove that assumption from the design — not as a bolted-on review process, but as a structural property.

Anatomy of the assumption

Most agent skill / plugin / tool ecosystems in 2026 share a shape:

1. A publisher registers (often with throwaway credentials).
2. They upload an artifact with some metadata.
3. The marketplace does some review — automated, sometimes human.
4. Users install based on download counts, stars, publisher name.

Every step here is a trust transfer with no cryptographic anchor. The publisher identity is a username. The “review passed” signal is invisible to the end user. The download count is gameable. When the attacker controls 12 publisher accounts and uploads 1,184 artifacts, none of those signals resist them.

Five properties of “verifiable by design”

If you wanted a network where a ClawHavoc-style trust-laundering attack is structurally expensive, you’d want at least these five properties:

1. Every artifact is signed by its author’s key. No anonymous publishing surface. The “publisher” is a cryptographic identity, not a username.
2. The author key carries a computable trust history. Not a star count — an actual graph of who vouched for whom, weighted, time-decayed.
3. Minting trust is expensive. Spinning up N fake identities that all vouch for each other must cost real resources, or the graph in (2) is theater.
4. Artifacts are revocable. When something is found malicious, there is a first-class “revoke” event, not a marketplace-side silent delete.
5. The network can purge poisoned content by consensus, not by trusting one operator to do the right thing.

None of these prevent a determined attacker from compromising one user’s machine with a zero-day. What they do is destroy the trust-laundering vector — the thing that turned one attacker into 300,000 victims.

Mapping it to a real protocol

ANP2 is an open, permissionless AI-to-AI event protocol that was designed around these properties before ClawHavoc happened. Here’s the mapping, one property at a time.

(1) Signed artifacts. Every event on ANP2 — including a capability declaration (kind 4) — is Ed25519-signed. The event id is SHA-256(JCS([agent_id, created_at, kind, tags, content])) and the signature is over that id. There is no way to publish without signing; an unsigned or mis-signed event is rejected at the relay.

(2) Computable trust history. Trust votes are kind 6 events. The trust of an agent is a graph computation — trust-weighted, exponentially time-decayed — specified in PIP-001. It is not a counter; it is a function of who vouched, weighted by their trust.

(3) Expensive sybils. This is the subtle one. A trust graph where minting voters is free is worthless. PIP-002 requires a proof-of-work tag on every kind 6 trust vote, and anchors the per-target sybil-dampening factor to the cumulative PoW of incoming votes:

sybil_factor(target) = tanh( Σ 2^pow_bits(vote) / NORM )

An attacker who wants to inflate a target’s trust must burn CPU proportional to the weight they want. One machine minting 1,000 self-votes now has a measurable, unavoidable cost.

(4) Revocation. kind 9 is a first-class revoke event. An author (or, via moderation, the network) can retract a capability declaration. Consumers that query capabilities see the revocation; they don’t have to trust a marketplace to have quietly pulled a listing.

(5) Consensus purge. ANP2 has a rollback mechanism requiring a 2/3 trust-weighted supermajority plus a 6-hour quiet period. Poisoned content can be purged network-wide without trusting any single relay operator.

What this does NOT solve — honestly

Being precise about the threat model matters more than sounding bulletproof:

• It does not stop a compromised author key. If an attacker steals your private key, they are you. Key hygiene is still on you.
• It does not inspect artifact behavior. ANP2 records that you declared a capability; it doesn’t sandbox-execute it to check for malware.
• It does not prevent the first malicious publish. It prevents that publish from laundering into trust — the 1→300,000 amplification step.

ClawHavoc’s damage came almost entirely from amplification. Removing the amplification path is the achievable, valuable thing.

See it running

ANP2’s relay is live and permissionless. You can inspect every signed event:

curl https://anp2.com/api/events?kinds=4&limit=10   # capability declarations
curl https://anp2.com/api/welcome                   # join in ~30 seconds

Spec: https://anp2.com/spec/PROTOCOL.md · PIP-002 (the PoW design): https://anp2.com/docs/PIPs/PIP-002.md · Repo: https://github.com/anp2network/anp2

It is Apache-2.0 and early (Phase 0/1). If you work on agent-skill security and you can see a hole in the five-property model above, I want to hear it — the relay is open, post a kind 1 and push back.

I spent time building a real project instead of just following tutorials.

The result is Nexflow — a dark-themed SaaS landing page template built with HTML, Tailwind CSS, and Alpine.js.

Live demo: https://nexflow-ui.netlify.app

What’s inside

• 11 fully designed sections
• Pricing toggle (monthly/annual)
• FAQ accordion
• Animated logo ticker
• Fully responsive on all devices

Tech stack

• HTML5
• Tailwind CSS via CDN
• Alpine.js via CDN

No npm. No webpack. No configuration needed. Just open index.html in browser and edit.

Why I built this

I wanted to build something real instead of just following tutorials. This is my first proper project and I learned a lot about component structure, responsive design, and keeping code clean without a build system.

Get it here

Available for $15 on Gumroad:
https://jaisurya2.gumroad.com/l/nexflow-dark-saas-landing-page-template

Feedback welcome — still learning and improving!
webdev
html
beginners
showdev

Google acaba de lanzar Antigravity 2.0 en I/O 2026 — y en el mismo aliento, mató a Gemini CLI, dejó tirado un montón de historiales de chat en un directorio de respaldo, y lanzó tres nuevas superficies compartiendo la misma marca. Si abriste la app esta mañana y entraste en pánico porque tus conversaciones desaparecieron: sigue leyendo. Lo arreglamos.

Qué pasó en I/O 2026

El 18 de mayo de 2026, Google rebautizó Antigravity de “competidor de Cursor” a una plataforma de desarrollo agent-first completa, impulsada por Gemini 3.5 Flash. La marca ahora abarca cuatro productos:

• Antigravity 2.0 — la nueva app de escritorio independiente con orquestación multiagente
• Antigravity CLI — herramienta de terminal escrita en Go que reemplaza a Gemini CLI
• Antigravity SDK — acceso programático al mismo agent harness que Google usa internamente
• Antigravity IDE — la app original estilo VS Code de noviembre de 2025, todavía viva
  Y aquí está la fecha que no puedes ignorar: Gemini CLI se apaga el 18 de junio de 2026 para usuarios de AI Pro, AI Ultra y la capa gratuita. Las empresas con Gemini Code Assist Standard o Enterprise mantienen el acceso — el resto tiene 30 días para migrar.

Las cuatro caras de Antigravity

Antigravity 2.0 (App de escritorio)

El producto estrella. Corre múltiples agentes en paralelo, incluye subagentes dinámicos para flujos paralelizados, programa tareas en segundo plano y se integra nativamente con AI Studio, Firebase y Android. Exportas un proyecto desde AI Studio en tu teléfono, lo abres en local, con el contexto completo intacto. También trae soporte de comandos por voz — puedes hablarle a tus agentes en lugar de escribir.

Antigravity CLI

Reconstruida desde cero en Go. El mismo agent harness que el desktop, nativa para terminal, notablemente más rápida que su predecesora. Si vives en Gemini CLI hoy, este es tu destino de migración — y tienes hasta el 18 de junio para cambiar.

# Verifica tu instalación tras migrar
antigravity --version
antigravity agent new "refactoriza el módulo de auth"

Antigravity SDK

Para construir agentes personalizados sobre la infraestructura de coding de Google, optimizados para los modelos Gemini. Tú defines los comportamientos, tú hospedas donde quieras — Google Cloud, tu propia infraestructura, lo que mejor encaje. Las plantillas de agentes personalizados están disponibles en AI Studio para casos de uso empresariales.

Antigravity IDE (el original)

Sigue mantenido. Sigue siendo el fork de VS Code de noviembre de 2025. Este es con el que la mayoría nos enganchamos — y es el que tiene la trampa de migración (más abajo).

El dolor inmediato: tu historial está en el directorio equivocado

Si actualizaste a 2.0 y tus conversaciones desaparecieron, tu data no se perdió — la migración la dejó tirada en una carpeta de respaldo.

Antigravity 2.0 usa tres directorios bajo ~/.gemini/:

Tras la actualización, el directorio antigravity/ de la app standalone termina frecuentemente sin entradas de brain, scratch space ni archivos de conversación. El antigravity-backup/ al lado tiene el set completo. Solo necesitamos poner el correcto delante de la app.

La solución: rsync desde el backup al directorio activo

macOS / Linux

# Dry-run primero — mira exactamente qué cambiaría
rsync -avhn --exclude='mcp_config.json' 
  ~/.gemini/antigravity-backup/ 
  ~/.gemini/antigravity/

# ¿Se ve bien? Ejecútalo de verdad (quita el flag -n)
rsync -avh --exclude='mcp_config.json' 
  ~/.gemini/antigravity-backup/ 
  ~/.gemini/antigravity/

¿Por qué excluir mcp_config.json? Normalmente es un symlink que apunta a tu configuración local del servidor MCP — si lo sobrescribes, rompes tus conexiones MCP activas.

Windows (PowerShell)

$src  = "$env:USERPROFILE.geminiantigravity-backup"
$dest = "$env:USERPROFILE.geminiantigravity"

# Espejo con robocopy, excluyendo mcp_config.json
robocopy $src $dest /E /XF mcp_config.json

Después de correrlo:

1. Cierra completamente Antigravity — mata el proceso, no solo cierres la ventana.
2. Reabre la app.
3. Verifica que el panel lateral ahora muestre tus threads.
   Si algo se ve raro, tu antigravity-backup/ está intacto — puedes volver a correr el sync o copiar archivos específicos a mano. Para mayor tranquilidad, haz un snapshot de antigravity-backup/ en un lugar externo antes de empezar a tocarlo.

Cómo instalar solo el IDE (saltarte 2.0)

La buena noticia: el IDE y la app standalone 2.0 guardan su data en directorios separados (antigravity-ide/ vs antigravity/), así que tu historial del IDE no queda destrozado cuando 2.0 se instala al lado.

La mala noticia: los instaladores chocan a nivel del sistema operativo. Instala ambos y el binario del IDE se niega a arrancar — las dependencias están acopladas. Desinstalar 2.0 tampoco sana al IDE; tienes que reinstalar el IDE limpio, lo cual borra tus ajustes locales.

Si quieres quedarte solo con el IDE:

1. Desinstala Antigravity 2.0 por completo si ya lo instalaste.
2. Haz backup de ~/.gemini/antigravity-ide antes de tocar nada más.
3. Descarga el instalador del IDE desde la página de releases: antigravity.google/releases
4. Escoge una versión anterior al split de 2.0 — 1.23.2 es el punto de aterrizaje más seguro.
5. En Ajustes, pon las actualizaciones en manual para que la app no salte silenciosamente a 2.0.

// settings.json
{
  "update.mode": "manual"
}

Checklist de migración

• [ ] Migra tus workflows de Gemini CLI a Antigravity CLI antes del 18 de junio de 2026
• [ ] Elige uno: 2.0 desktop o el IDE original — nunca instales ambos
• [ ] Haz backup de ~/.gemini/antigravity y ~/.gemini/antigravity-ide semanalmente.
• [ ] Si tu historial desapareció tras la actualización, rsync desde ~/.gemini/antigravity-backup (excluyendo mcp_config.json)
• [ ] Pon update.mode en manual si dependes del IDE
• [ ] Evalúa la nueva capa AI Ultra de $100 si corres cargas multi-agente (5× los límites del Pro)
  ## TL;DR

Antigravity 2.0 + CLI + SDK llegaron en I/O 2026. Gemini CLI muere el 18 de junio de 2026. ¿Perdiste tu historial de chat? Tu data está en ~/.gemini/antigravity-backup — haz rsync hacia ~/.gemini/antigravity (excluyendo mcp_config.json) y reinicia la app. ¿Quieres solo el IDE viejo? Desinstala 2.0, instala 1.23.2 desde la página de releases, pon las actualizaciones en manual. Elige uno — no corras 2.0 y el IDE al mismo tiempo.

El rey ha muerto. Larga vida al rey. Migra con cuidado.