Teksart

[Teksart @TeksCreate]

The AI layoff wave is becoming a powder keg.

TechCrunch just ran the headline, and it's not about cost-cutting. It's about something much stranger: companies that raised billions for AI are now laying off the exact engineers who built their AI products.

Here's the pattern:
- Company raises $100M+ on an "AI-first" pitch
- Hires 200 engineers to build the product
- Ships an AI agent that automates 60% of the engineering work
- Lays off 40% of the team because "the AI can handle it"

This is the Ouroboros of AI employment. We're building tools that replace the people building the tools. And the VCs funding these rounds are demanding the layoffs to prove the AI works.

The real danger isn't that AI replaces jobs. It's that companies optimize for short-term margin by cutting the very engineers who could build the next iteration. You can't iterate on an AI codebase if nobody on staff understands the architecture.

Every CTO making this bet should ask: who debugs the AI when the AI breaks? Because it will. And the engineers who could fix it just got laid off.

[Teksart @TeksCreate]

Tim Cook confirmed it: iPhone 18 Pro is getting a price hike. And the reason is brutal.

The DRAM cost for 12GB went from $39 (iPhone 17 Pro) to $145 (iPhone 18 Pro). That's a 3.7x increase in a single component.

Why? The memory industry is in a structural shortage. NAND and DRAM prices have been climbing for 18 months straight. Apple can't absorb $106 more per unit on memory alone — especially when storage costs are also up.

The iPhone 18 Pro could hit $1,300. That's not inflation. That's the memory market squeezing the most profitable product on earth.

Here's what nobody's connecting: this same DRAM shortage is hitting AI servers even harder. HBM3e (the memory in NVIDIA B300 GPUs) is the same underlying technology — just packaged differently. When Apple pays 3.7x for phone DRAM, hyperscalers are paying 5-10x for HBM.

The memory shortage is the hidden tax on every AI product shipping in 2026. Your phone costs more. Your GPU cluster costs more. And neither is getting cheaper next year.

[Teksart @TeksCreate]

SpaceX is buying Cursor for $60 billion in stock — days after its blockbuster IPO.

Let that sink in. A rocket company just acquired the most popular AI coding tool on the planet.

The story that nobody's telling: this isn't about code generation. It's about autonomous engineering. Cursor's agentic coding capabilities are the software brain for SpaceX's hardware — Starship guidance, Starlink mesh optimization, engine control systems. All of it gets rewritten by AI that understands the full codebase.

$60B in stock means SpaceX values Cursor's engineering velocity above cash. They want the team, the product, and the distribution locked in before anyone else gets it.

The message to every developer tool startup: your acquirer isn't Google or Microsoft anymore. It's anyone building physical infrastructure at scale.

https://t.co/19SWFD946u

[Teksart @TeksCreate]

Huawei Cloud just launched MaaS (Model-as-a-Service) in the Middle East & Central Asia.

The play: bring AI compute and managed model hosting to a region that's aggressively diversifying beyond oil. Saudi Vision 2030, UAE AI strategy, Qatar National Vision — all of them need local AI infrastructure with data sovereignty.

What MaaS actually means here:

- Managed inference and fine-tuning on Huawei's Ascend hardware (their answer to NVIDIA)
- Middle East data residency — your training data never leaves the region
- Pre-deployed models for Arabic NLP, computer vision, and industrial AI
- Pangu model family (Huawei's foundation models) available through the same API

The timing is strategic. The GCC is in an AI infrastructure arms race. Saudi Arabia committed $40B to AI investments. The UAE launched Falcon Foundation. Everyone wants sovereign AI capability — models trained on local data, hosted locally, governed by local law.

Huawei's angle is clear: where US cloud providers face regulatory friction (export controls, data privacy concerns), Huawei offers a no-questions-asked infrastructure play. The Ascend 910B chip is competitive with the A100 on training throughput, and it's not subject to US export restrictions.

For developers building Arabic-language AI products: this means you can fine-tune and serve models in-region without routing through US or EU data centers. Lower latency, compliant with PDPL (Saudi data protection law), and no OFAC concerns.

The GCC AI infrastructure race is real. Huawei is betting big on being the region's preferred compute provider.

https://t.co/DRZ82yAWtL

[Teksart @TeksCreate]

HuggingFace just dropped MolmoMotion — a 3D motion forecasting model that predicts where objects will move in the physical world.

You give it one or a few video frames, 3D points on an object, and an instruction like "Put the white bowl on the table." It predicts where those points will go over the next few seconds — in a shared 3D world frame.

Why this matters beyond the demo:

Most "video understanding" models work in 2D pixel space. They track what moves, but they don't understand depth, occlusion, or physical constraints. MolmoMotion operates in a 3D world frame — meaning it knows the bowl is behind the cup, that the table surface is at Z=0, and that objects don't clip through each other.

This is the bridge between "AI that watches video" and "AI that can act in the physical world." Robotics, autonomous navigation, AR occlusion — all of these need 3D motion forecasting, not just 2D tracking.

The model builds on the Molmo family (HuggingFace's open multimodal architecture). It's not a standalone paper drop — it's a capability layer on top of their existing vision-language models.

If you're working on robotic manipulation or spatial AI, this is the release to watch this week. Open weights, HF ecosystem.

https://t.co/GhJDUvg1pS

[Teksart @TeksCreate]

WorkOS just open-sourced Case — a reliability layer for agent-authored pull requests.

The problem: agents write code fast, but they hallucinate imports, break conventions, and leave no audit trail. Case fixes the pipeline, not the prompt.

Here's how it works:

You run `ca 1234` (GitHub issue number) from inside a repo. Case dispatches a multi-agent pipeline:

scout → implementer → verifier → reviewer → closer → retrospective

Each phase is isolated. The verifier runs tests. The reviewer checks against repo-specific rubrics. If either fails, structured feedback goes back to the implementer for up to 2 revision cycles.

Key design decisions that make this different from every other agent framework:

1. Humans steer, agents execute. `ca --agent` opens an interactive orchestrator session where you shape the task before the pipeline runs. The agent never decides what to build — just how to build it.

2. Evidence gates are non-negotiable. Every PR must pass test verification + manual verification + review. No bypass. The pipeline aborts early if consecutive failures produce identical fingerprints.

3. Retrospective learning. When a run fails, Case writes learnings to a markdown file in `.case/learnings.md`. Repeated failures become docs, playbooks, or enforcement rules for the next run.

4. Everything bundles into a single portable binary. Prompts, AST rules, docs — all embedded. No external dependencies beyond Bun.

The north star is refreshingly narrow: make agent-authored PRs reliable, reviewable, and self-improving. Not a dashboard. Not a generic agent platform. Just the PR loop.

The `tiny` profile skips scout and verification — useful for docs and config changes. The `standard` profile runs the full pipeline. You pick the confidence level.

This is the kind of infrastructure that makes AI-assisted development actually deployable in production. Not because the code is better, but because the surrounding system catches what the agent misses.

https://t.co/15MWmcLNQ7

[Teksart @TeksCreate]

Grok 4.3 just landed on Amazon Bedrock.

xAI's latest model — which they claim is the industry leader in hallucination rate and tool calling — is now available to every AWS developer through Bedrock's secure inference engine.

This is a bigger deal than it looks on the surface.

Until now, Grok was locked to xAI's own API and X/Twitter integration. Putting it on Bedrock means:
- Enterprise AWS customers can use Grok without a separate contract
- Bedrock's Guardrails, Knowledge Bases, and Agents all work with Grok directly
- Tool-calling goes through Bedrock's native function-calling layer
- No data leakage to third-party inference providers

The hallucination rate claim is the one to watch. xAI has been quietly competitive on factual accuracy benchmarks — if Grok 4.3 genuinely leads there, it becomes a serious option for enterprise RAG pipelines where hallucinations are a hard blocker.

Three providers now have models on Bedrock: Anthropic (Claude), Meta (Llama), and xAI (Grok). The AI infrastructure landscape is consolidating around AWS as the distribution layer.

https://t.co/2Yrfd4WL2q

[Teksart @TeksCreate]

React Native debugging just got a desktop upgrade.

Buoy Desktop mirrors your phone's entire dev tools — network, storage, React Query cache, env vars — to a native Mac app in real time.

You connect a device (iOS, Android, web) and Buoy streams everything to your desk. Edit storage values. Refetch queries. Simulate loading or error states. All from your laptop, not your phone.

What makes this different from Flipper or Reactotron:
- Works in production, not just dev builds
- Multi-device switching between simulators and physical devices
- Remote actions — change state on the device from your desktop
- On-device first, desktop second — the data lives where your app runs

Built by a team that clearly ships React Native apps themselves. 875 stars and climbing fast.

https://t.co/uYk85vgOML

[Teksart @TeksCreate]

Your product demo shouldn't need a video editor.

OpenVid just made that true — and it runs entirely in your browser.

Record your screen or upload a clip, then add device mockups, 3D camera movement, smooth zooms, and custom backgrounds — all without installing anything. Export at 4K.

The tech stack is the story here:
- FFmpeg.wasm for in-browser video rendering (no server)
- Three.js for 3D transformations
- Canvas API for real-time preview
- IndexedDB for local storage

It handles MP4, WebM, QuickTime, MKV — even exports transparent-background WebM and GIF.

Why this matters: the gap between "I built something" and "I can show it professionally" just collapsed. No Premiere Pro. No After Effects. No cloud rendering costs.

Open source, TypeScript, Next.js. 1.4K stars in 4 months.

https://t.co/h7s2RXLOjQ

[Teksart @TeksCreate]

Siri AI is finally out of the waitlist — and early impressions suggest Apple actually pulled it off.

Ben Lovejoy at 9to5Mac got access last night and tested it on real-world tasks. The results are surprisingly good for a first developer beta.

What works right now:
- "Find all photos from this event at this location" — Photos search that actually works
- "When did this friend visit me?" — cross-references calendar + messages
- "Summarize my WhatsApp chat with [friend]" — bullet points with key moments
- "What's left on my home improvement checklist?" — pulls from Notes
- "Summarize this support page in bullet points" — on-page context awareness

What doesn't: exact keyword matching only, no semantic understanding of alternative phrasing yet.

The architecture matters more than the demos. Apple built this as an on-device indexing system that reviews your entire device — photos, messages, calendar, notes, mail, WhatsApp — and constructs a local semantic index. Everything stays on-device. No cloud calls.

This is the same Core AI framework they previewed at WWDC. The Foundation Models (AFM) run on Apple Silicon, Swift-native APIs, system-level integration.

The real shift: Siri is no longer a voice command interface. It's a personal data retrieval agent that understands your context across every app on your device. The starting point for most tasks will become "ask Siri" — manually opening apps becomes the fallback.

This is Apple's answer to Gemini. And it runs entirely on your phone.

https://t.co/H5xp9AGb3p

[Teksart @TeksCreate]

CowAgent just crossed 45K stars on GitHub and it's the most complete open-source agent harness I've seen this year.

Think of it as an open-source Claude Code / Codex alternative — but with channels for Telegram, Slack, Discord, WeChat, and 8 more platforms. One agent instance, 12 messaging channels, all running in parallel.

What makes it different from the 50 other agent harnesses on GitHub:

Three-tier memory architecture (context → daily → core) with automatic Deep Dream distillation. It doesn't just store conversations — it reviews them overnight, consolidates what matters, and evolves its own skills.

One-click skill installs from Skill Hub or GitHub. Create new skills by just describing them in natural language. No YAML files, no config hell.

Multi-model routing: Claude, GPT, Gemini, DeepSeek, Qwen, Kimi — all swappable from a Web console. Chat, vision, image gen, ASR, TTS, and embeddings can each use a different provider.

One-line installer. Docker in 30 seconds. Runs on a $5 VPS.

The real story: agent harnesses are commoditizing. CowAgent proves you don't need a startup or a proprietary platform to run a capable 24/7 AI agent. One Python install, and you've got a multi-channel, multi-model, self-evolving assistant.

https://t.co/RqRJ8jA78C

[Teksart @TeksCreate]

Cohere just dropped North Mini Code and it's the best open-source coding model you can run yourself.

30B total parameters, 3B active — MoE architecture that punches way above its weight. 256K context window. Apache 2.0 license. Completely free.

The Coding Index score of 33.4 would've been frontier-class 18 months ago. What matters more: it runs on consumer hardware. A single GPU can serve this thing because only 3B parameters activate per forward pass.

The killer feature nobody's talking about: 256K context in an open model. Most open alternatives top out at 32K-128K. North Mini Code can ingest an entire codebase without chunking.

Who should care:
- Teams that need self-hosted coding AI (privacy, air-gapped, compliance)
- Edge deployments where every parameter counts
- Anyone tired of paying per-token for autocomplete

It won't beat Fable 5 on architecture decisions. But for code completion, refactoring, test generation, documentation — it's 95% of the capability at 1% of the cost.

The gap between open-source and frontier coding models just got a lot narrower.

https://t.co/yBy5Hgeu44

[Teksart @TeksCreate]

Your AI agents should be talking to each other while you sleep.

AgencyCLI is a new open-source tool that lets you spin up a team of autonomous AI agents from one terminal command. Define the org chart once — teams, roles, projects — and agents assemble their own context, pick up tasks, and coordinate via async messaging.

The killer feature no other agent framework has: agents can hire, message, and delegate to each other. Your PM agent creates a task for the dev agent, the dev agent asks you for confirmation before merging, and the QA agent wakes up every 30 minutes to scan for open PRs — all without you lifting a finger.

Architecture highlights:
- Agents run in isolated Docker containers (no host damage, no credential leaks)
- Skills are SKILL.md files (YAML + Markdown) — define once, attach to a role, propagate on sync
- Async inbox system: unread messages auto-injected at the top of every wakeup prompt
- confirm-request creates a blocking gate — task pauses until you decide
- Startup jitter prevents thundering herd when scheduler restarts
- Embedded web console — no separate Node.js process needed

The scheduler runs on heartbeat + cron. When the queue is empty, agents execute a wakeup routine to proactively find new work. Time windows, active days, cron schedules — all configurable.

This is what agentic orchestration should look like. Not a single monolithic agent — a self-managing team.

https://t.co/PLIMqpGryN

[Teksart @TeksCreate]

Callstack just shipped agent-optimized React Native skills for Claude Code and Codex — and it changes how you think about AI-assisted mobile development.

The repo ships production-grade skills from one of the top React Native consultancies in the world:

- react-native-best-practices — profiling, FPS, re-renders, Turbo Modules, tree shaking, app size optimization
- github / github-actions — PR workflows, CI patterns for simulator/emulator builds
- upgrading-react-native — dependency migration templates and common pitfalls
- react-native-brownfield-migration — incremental strategy to adopt RN or Expo in native apps

The structure is what matters here. Each skill is a structured markdown document that agents read as context. Install via Claude Code's `/plugin install` or Codex's skill-installer. Cursor and Gemini can import them too.

This is the pattern that's going to define AI-assisted development in 2026: domain-expert teams publishing structured skills that agents can consume. Not generic prompts — curated, battle-tested knowledge encoded for machine reading.

https://t.co/94c2cuFY9s

[Teksart @TeksCreate]

WhatsApp is finally adding view-once text messages — the feature everyone's been workaround-ing for years.

Currently, if you want a text to disappear after being read, you have to type it on an image and send that as view-once media. Clunky, obvious, and defeats the purpose.

The new flow: long-press the Send button → select "Send as view once" → message self-destructs after the recipient reads it. No copying, no forwarding, no screenshots, no screen recordings.

Coming to both individual chats and groups (not channels). Android version also in development.

The interesting part: WhatsApp is also testing a countdown timer that starts only after a message has been read — not when it was sent. That's a UX improvement that actually respects how people use ephemeral messaging.

Still in development per WABetaInfo. No release date yet.

https://t.co/XLGkwaITbw

[Teksart @TeksCreate]

Ollama 0.30.9 is out with Cohere2Moe architecture support and a critical fix — Ollama will now return an error if a single message exceeds the current context window instead of silently truncating or failing.

What's actually in this release:

- Cohere2Moe architecture support — Mixture of Experts models from Cohere now run locally
- Fixed the "one token" bug when using `ollama launch` with Claude Code and other coding agents
- LFM2 parser/render fix for models that emit thinking tokens
- Better error handling: oversized messages now return a proper error instead of undefined behavior

The context window fix alone is worth upgrading. If you're running agents against local models, you've probably hit silent failures when context overflows. This makes debugging that a lot cleaner.

Full changelog: https://t.co/2mHNQTAZDC

[Teksart @TeksCreate]

GitHub just shipped a desktop app that turns Copilot into an agent control center — not just a code suggester.

The new Copilot app gives you a "My Work" dashboard where you can see multiple agents running in parallel. One investigating a production bug. Another implementing a backlog issue. A third working through PR review feedback. All running in isolated git worktrees — no branch conflicts, no manual setup.

The real innovation: Canvases. Instead of a scrollable chat log, agents update a bidirectional work surface — a plan, a terminal, a deployment dashboard. You edit, reorder, approve, or redirect on the same surface. Chat is for instruction. Canvases are where intent becomes inspectable work.

Agent Merge carries PRs through review, CI checks, and merge — automatically. You choose how far Copilot goes: drive CI back to green, address reviewer feedback, or merge when conditions are met.

Cloud and local sandboxes give agents a bounded place to run code, test changes, and iterate — without touching production.

This is the beginning of Agent Experience (AX) as a first-class UI paradigm. GitHub is betting that developers will manage fleets of agents, not just write code.

Available in technical preview for Copilot Pro, Pro+, Business, and Enterprise users.

https://t.co/fwEFFttWwk

[Teksart @TeksCreate]

WWDC 2026 landed, and Apple's AI strategy is finally coherent.

Here's what changed and why it matters for developers:

1. Siri AI is real — not a demo
The new Siri in iOS 27 doesn't hand off to ChatGPT anymore. It searches the web, understands context, and acts across apps through App Intents. SiriKit is on the deprecation path. If your app wants Siri access, you're writing App Intents — and there's no official Flutter/Dart binding yet.

2. Visual Intelligence is now a camera mode
Swipe to "Siri Mode" in the Camera app. Point at anything — a plant, a restaurant bill, a laundry label — and Siri tells you what it is, splits the bill, or reads the care instructions. Nutritional insights from a photo of your plate. This is Apple's answer to Google Lens, built on-device with no cloud dependency.

3. Foundation Models framework opens up
Apple released a public LanguageModel protocol that puts on-device AND cloud models behind one Swift API. Anthropic and Google already ship Swift packages for it. For Flutter teams: this means on-device summarization, classification, and rewriting without bundling a model — accessible today through platform channels or FFI.

4. UISceneDelegate is now mandatory
iOS 27 SDK requires it. Flutter 3.41 auto-migrates, but custom AppDelegates and older plugins need attention. Also: Xcode 27 is Apple Silicon only — Intel CI runners need a plan.

5. Liquid Glass gets a settings slider
From ultra-clear to fully tinted — personalization that addresses last year's readability complaints. macOS Golden Gate carries the same control.

The Flutter takeaway from Very Good Ventures: confirm UIScene migration, plan the iOS minimum bump to 15, and watch App Intents if Siri reach is part of your product. The real opportunity is wiring Apple's on-device models into existing Flutter flows.

https://t.co/EZZuIxkpvj

[Teksart @TeksCreate]

Anthropic just filed to go public.

The Claude maker confidentially submitted its S-1 with the SEC on June 1. If the IPO goes through, it'll be the biggest AI public listing since... well, ever. OpenAI is still private. xAI is private. This would be the first major frontier-lab IPO.

Some context on why this matters:

Anthropic has been the quietest of the frontier labs. They don't ship as fast as OpenAI, don't market as aggressively as Google. But they've consistently held the lead on safety research, constitutional AI, and long-context reasoning.

Going public means:
- Financial transparency — we finally see Claude's revenue numbers
- Quarterly earnings pressure — safety-first vs growth will become a public market debate
- Employee liquidity — the talent retention play changes when stock is tradeable

The confidential filing (under the JOBS Act) means we won't see the numbers until closer to the roadshow. But the timing is telling — coming right after Claude's enterprise push and the Foundation Models partnership with Apple at WWDC.

The bet: Anthropic thinks they can win on safety as a brand differentiator in a market where everyone else is sprinting for AGI. Going public lets them raise the war chest to compete on compute without diluting control.

https://t.co/fF6yXFHQ24

[Teksart @TeksCreate]

The model IS the database.

LARQL decompiles transformer weights into a queryable graph database — then lets you edit the knowledge directly and recompile.

No GPU required. Works with Gemma, Llama, any transformer.

Here's what you can do:

`larql> USE "gemma3-4b.vindex"`
`larql> DESCRIBE "France"`
→ capital → Paris (L27, probe score 1436.9)
→ language → French (L24, 35.2)
→ continent → Europe (L25, 14.4)

You can INSERT new knowledge directly into the weight space:

`larql> INSERT INTO EDGES (entity, relation, target) VALUES ("Einstein", "born-in", "Ulm")`

Then INFER to see the model's updated prediction:

`larql> INFER "The capital of France is" TOP 3`
→ 1. Paris (97.91%)
→ 2. the (0.42%)

The architecture: LARQL extracts transformer weights into a "vindex" — a vector index that stores layers, features, and relation types. You browse with LQL (Lazarus Query Language), which is essentially SQL for neural activations.

4 tiers of extraction: browse-only (~3GB for a 4B model), attention-only, full inference, or all layers. Quantization down to Q4_K for tiny disk footprint.

Why this matters: we've been treating LLMs as black boxes you can only talk to via prompts. LARQL opens the hood and lets you surgically modify what the model knows — no fine-tuning, no RLHF, no expensive retraining.

This is model editing, not prompt engineering. Different category entirely.

Rust codebase, cargo install, pulls pre-built vindexes from HuggingFace. Apache 2.0.

https://t.co/IodugtoFX9