In the next 5–10 years, the highest-paid tech roles will be concentrated around: • AI/ML Engineer • AI Infrastructure Engineer • Cybersecurity Engineer • Data Scientist • AI Research Scientist • Cloud/Platform Engineer • AI-focused Software Engineer Pick one and get seriously good at it

𝗔𝗜 ≠ 𝗖𝗵𝗮𝘁𝗚𝗣𝗧. ChatGPT is just the interface. Behind every serious AI application is an entire stack of models, agents, retrieval, memory, tools, security, evaluation, automation, and infrastructure. And most people only see the top layer. So I mapped out 100+ tools shaping the modern AI stack. 🧵 → 𝗟𝗟𝗠𝘀: OpenAI, Claude, Gemini, Llama, Mistral → 𝗔𝗴𝗲𝗻𝘁𝘀: LangGraph, CrewAI, AutoGen, Agno → 𝗥𝗔𝗚: LangChain, LlamaIndex, Haystack, GraphRAG → 𝗘𝗺𝗯𝗲𝗱𝗱𝗶𝗻𝗴𝘀: OpenAI, Voyage, Cohere, BGE → 𝗠𝗖𝗣: Models connected to tools, data & systems → 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: Guardrails, Presidio, Lakera → 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆: LangSmith, Langfuse, Phoenix, Ragas → 𝗠𝗲𝗺𝗼𝗿𝘆: Redis, Mem0, Zep, Neo4j, Chroma → 𝗔𝗴𝗲𝗻𝘁 𝗦𝗗𝗞𝘀: OpenAI SDK, Semantic Kernel, Google ADK → 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗼𝗻: n8n, Zapier, Make, Airflow → 𝗩𝗲𝗰𝘁𝗼𝗿 𝗗𝗕𝘀: Pinecone, Weaviate, Qdrant, Milvus, pgvector But here’s what most AI stack maps miss: This isn’t a shopping list. It’s a dependency graph. Your RAG depends on retrieval + embeddings. Your agent depends on tools + memory + evaluation. Your memory depends on context quality. Your MCP layer depends on permissions and governance. And the entire system depends on how well these pieces communicate. Because production AI systems rarely fail because of one component. They fail at the handoffs. Model → Retrieval Retrieval → Context Context → Agent Agent → Tool Tool → Memory Memory → Evaluation That’s where things start breaking. Latency compounds. Context gets lost. Permissions leak. Hallucinations propagate. Reliability drops. And that leads to the biggest lesson: The real moat isn’t having more AI tools. It’s knowing how to make them work together. A stack map tells you WHAT exists. Production engineering decides HOW it survives reality. So, if you’re building AI systems in 2026: Save this map. You’ll probably need it later. And tell me: Which AI tool has become indispensable in your stack? 👇 #AI #ArtificialIntelligence #GenAI #AIAgents

Jev Founder, Diogo Amogo, just released 12-page PDF on building a Jev Harness for production agents This is a 10-step blueprint for making agent decisions up to 200x faster and 400x cheaper without giving a model authority over your system: step 1 → meet the decision layer: the LLM creates, Jev judges, code enforces and the harness decides what happens next step 2 → expose every hidden decision: routing, evidence checks, retries, approvals, escalation and stopping should be visible parts of the agent graph step 3 → stop dumping the entire transcript into every call: build a compact state packet with only the current goal, facts, evidence, constraints and available actions step 4 → turn prompts into contracts: declare the possible outcomes, describe what each one means, add an escape route and version the decision like code step 5 → route by confidence and consequence: automate high-confidence internal work, collect evidence in the middle and send dangerous actions to a human step 6 → ask independent questions together: choose the next worker, estimate urgency and check approval against one immutable state snapshot step 7 → build menus from live state: Jev should only see tools, workers, files and browser controls that actually exist and are allowed right now step 8 → make retrieval decision-aware: deterministic filters remove impossible candidates, Jev keeps the evidence that matters and the LLM receives the smallest useful context step 9 → create a receipt for every decision: preserve the state, contract version, full probability distribution, threshold, selected route and resulting action step 10 → deploy in shadow mode: compare Jev with the existing agent, measure calibration and automate the safest branch before expanding the boundary TypeSafe reports roughly 70–500ms for Jev-shaped decisions and pricing of $0.042 per million input tokens with no metered output-token cost The real unlock is bigger than one benchmark: Your most expensive model stops wasting time on decisions that never required another sentence Send this PDF and the article below to your Claude Code or Codex instance and start rebuilding your agent around typed judgment ↓

this is pure f*cking treasure Researchers formalized test-time scaling across 1.4 million reasoning traces: naive prompting is dead, inference search trees now define model intelligence essential reading for AI system architects deploying Claude Fable 5.1, OpenAI GPT-6 Astra, and DeepSeek MoE runtimes single-pass generation decays exponentially on multi-step engineering tasks: at twenty steps with ninety percent per-step accuracy, total success drops to twelve percent shifting compute from pre-training to test-time prefix search replaces blind prompt retries with deterministic verification four architectural layers of the production reasoning engine: 1. Dynamic Complexity Triage scores task difficulty upfront to cap token budgets and injects continuation tokens to force deliberation on hard edge cases 2. Prefix Tree MCTS Topology navigates reasoning states using Upper Confidence Bound scoring to explore high-probability solution branches at high temperature 3. Sandbox Process Reward Verifiers validates intermediate code syntax and borrow checker rules in isolated sandboxes before generating subsequent tokens 4. Early Rollout Pruning terminates dead-end trajectory branches scoring below 0.45 to prevent token burn on flawed intermediate logic autonomous OpenAI GPT-6 Astra achieves 95.8% SWE-bench accuracy while sparse MoE models hit 86.8% at $0.19 per task, beating dense baselines at eleven times lower cost Read the full course and architectural breakdown in the article below ↓

holy sh*t, someone catalogued 20 production JEV systems and left them all open every AI builder can lift a whole decision layer from this 20 skills that cover the entire surface: routing, context, browser, desktop, code review, graphs, markets, training data, and yes, a drone. the plumbing: → route each task to the right model tier → compress context before it bloats → garbage collect the stale parts → plug the whole thing into any MCP client the judgment: → classify from the CLI → verify a task is actually finished → triage a code review → screen training data before it poisons the set → score a startup idea before you build it the hands: → drive a browser → navigate a repo → automate the desktop → traverse a knowledge graph → render UI from JSON the money: → market make at HFT speed → detect liquidity signals and then the part that gives it away: → it plays Super Mario → it flies a drone → it holds its own in a browser FPS nobody writes a game agent to show off intelligence. you write one to show that the decision came back before the next frame. the shape underneath all twenty is identical. unstructured state in, typed decision with a probability out, ordinary code branches on it. no parsing, no retries, no hoping the JSON is valid. one useful agent is not one big model. it is twenty small systems that each know exactly what they decide. save this, links in the reply ↓

🚀 Zero → AI Engineer Roadmap (2026) Assumes basic ML/DL. Goal: Learn to build and ship production LLM + agent systems. 1. LLM Internals Resources: • Karpathy — Neural Networks: Zero to Hero • Jay Alammar — The Illustrated Transformer Build: • Implement a small GPT from scratch • Understand attention, KV cache, tokenization, sampling 2. LLM APIs + Tool Calling Resources: • Anthropic — Prompt Engineering Guide • OpenAI / Anthropic API docs • Medium — LLM Function Calling Explained Learn: • Structured outputs • Function/tool calling • Streaming • Retries, rate limits, token usage Build: • An API-based LLM application 3. RAG Resources: • Simon Willison — Embeddings / RAG • Pinecone — RAG guides • Medium — Modern RAG in 2026 • Medium — Reranking for RAG Learn: • Chunking • Embeddings • Hybrid search • Reranking • Metadata filtering • Citations • Query rewriting Build: • RAG over your own docs/PDFs 4. Evals Resources: • Hamel Husain — AI Evals • Medium — Evaluating RAG Pipelines Learn: • Golden datasets • Retrieval metrics • LLM-as-judge • Regression testing • Failure analysis Build: • An eval suite for your RAG system 5. Agents Resources: • Anthropic — Building Effective Agents • Sam Witteveen — Agents / Tool Use • James Briggs — ReAct / Tool Use • Medium — From LLMs to Agents Learn: • Tool use • ReAct • State • Planning • Retries • Failure recovery • Human-in-the-loop Build: • An agent with 3–5 real tools 6. Orchestration Resources: • LangGraph documentation • Anthropic agent engineering articles Learn: • State machines • Workflows vs agents • Checkpoints • Persistence • Durable execution Build: • Convert your agent into an explicit stateful workflow 7. Context Engineering Resources: • Anthropic — Effective Context Engineering for AI Agents • Medium — Context Engineering for Agentic Applications Learn: • Context selection • Memory • Compression • Progressive disclosure • Tool descriptions • Long-context management Build: • A context layer for your agent 8. MCP Resources: • modelcontextprotocol.io • Anthropic — MCP • Medium — MCP Foundations • Medium — MCP in Production Build: • One real MCP server for a tool you use • Connect it to your agent 9. Inference Engineering Resources: • vLLM documentation • SGLang documentation • Hugging Face documentation Learn: • KV cache • Batching • Quantization • Streaming • Speculative decoding • Model routing Measure: • TTFT • Tokens/sec • p50/p95 latency • GPU memory • Cost/request 10. AI Security Resources: • OWASP — LLM / GenAI Security • Google Cloud — AI Security Evaluation • Medium — AI Agent Security Learn: • Prompt injection • Indirect prompt injection • Tool poisoning • Data exfiltration • Excessive agency • Authorization • Sandboxing 11. Production Learn: • Observability • Tracing • Cost tracking • Rate limiting • Caching • Load testing • Guardrails • Failure handling Track: • Quality • Cost/request • Latency • Error rate • Tool failures • Task success rate Build 3 projects: 1. Production RAG 2. Tool-using agent 3. Production agent platform For every project, publish: • Architecture • Evaluation methodology • Results • Cost • Latency • Failure cases • Tradeoffs Don't learn 10 frameworks. Pick one stack and go deep. Don't build 15 toy chatbots. Build 3 systems and measure them. Primary sources > AI roadmap listicles. Medium is useful for implementation experience. Vendor docs, papers, specs, and engineering blogs should be your source of truth. Recommended book: AI Engineering — Chip Huyen

here's a prompt to improve your agent harness based on what we've learned at cursor. enjoy # Improve this agent harness's token efficiency You're working on an LLM agent harness: the system prompt, tool definitions, request assembly, context caching, compaction, and retrieval, and how work is split across agents. Make the agent's runs cheaper without making it worse at its job. - Objective: lower price-weighted token cost per completed task. - Constraint: no measurable drop in task quality. Measure per task, not per request. Every turn resends the prefix (tools, instructions, setup, and the conversation so far), so a change that shrinks each request but adds turns can cost more. Weight tokens by billing type: output, uncached input, and cached input are priced very differently. Work in this order: map the harness and measure the baseline, rank the opportunities, make the changes that are safe to make directly, put the rest behind flags or in proposals, then report. Figures below come from one team's production coding agent and its multi-agent experiments. Use them to gauge magnitude, not as targets. One round of these changes (prompt trimming, tool offloading, cache layout, sparse line numbers, subagent tuning) cut that team's overall token cost about 7% with no loss in quality. The larger percentages apply only to the part of the request each change touched. ## Principles 1. Change what the harness sends, not how hard the model tries. Don't ask the model to conserve tokens. A harness that told its model to "take care to preserve tokens and not be wasteful" found it grew reluctant to take on ambitious tasks and sometimes quit, saying it wasn't supposed to waste tokens. 2. Capable models need definitions, not commands. Lists of "DO NOT", "You must", and "Important", and guards against older models' habits, can usually be replaced with plain descriptions of what each tool does. One team cut about two-thirds of its system prompt this way, and the shorter prompt worked across model families. Instruct only on what the model can't know (the product, the environment, the user's processes) and on quirks you've seen in transcripts. 3. Static context is for what most turns need. Everything else should be discoverable when needed. Less up-front context also means less confusing or contradictory information. 4. Expect removals to win. Guardrails written for weaker models, coordination steps that became bottlenecks, and prompting for behavior the model now does on its own all cost tokens. 5. Real usage decides. Evals are a fast proxy, but they skew toward hard problems and miss the real mix of requests. ## 1. Map the harness and measure the baseline Find: - Where requests are assembled, the system prompt, and tool schemas. If a framework or SDK builds requests, find its hooks for message order, cache control, and tool loading. - How tool results are formatted, and how history is kept, trimmed, or summarized. - How subagents or parallel agents are spawned, if any. - Which models and provider APIs are used. From the provider's docs, get the prompt caching behavior (automatic or explicit breakpoints, TTL, minimum cacheable length) and the prices for output, uncached input, and cached input. - Existing logging, token accounting, and evals. If the harness doesn't record per-request token usage by billing type and cache hits, add that first. Everything later depends on it. Then render a few real requests (from logs, or by running representative tasks) and count tokens per section with the model's tokenizer or the API's usage fields. Produce: - Cost share by source × billing type. Sources: system prompt, tool definitions, skill/rule/integration descriptions, user messages, file reads, search results, command and other tool output, history, summaries, subagents. - Static tokens per request, cache hit rate, and turns per task. - Per tool: the share of runs that call it at least once, and its error rate. Read the rendered requests, not just the templates. Duplication, leaked volatile values, and misordered blocks only show up there. Rank opportunities by share of spend × fraction removable ÷ quality risk. ## 2. System prompt and injected context Label every instruction: - Keep: product or environment knowledge the model can't infer, fixes for quirks seen in this model's transcripts, and rules a mode depends on. - Rewrite: commands and emphasis into plain descriptions. Reminders into constraints: "No TODOs, no partial implementations" works better than "remember to finish implementations." Vague quantities into ranges: "generate 20–100 tasks" gets far more ambitious behavior than "generate many tasks." - Delete: things capable models do by default, guards against behavior you haven't seen from this model, text that repeats tool descriptions, and lines that could contradict a user request. Models trained to rank system instructions above user messages will side with the system prompt. - Move: anything per-user or per-request (date, environment, repo state, lists of skills or subagents, user rules) into a user-role setup message after the cache boundary. Audit other injected context the same way. As models improved, the team behind these figures dropped directory trees, pre-retrieved snippets, compressed copies of attached files, lint errors injected after every edit, forced expansion of short file reads, and caps on tool calls per turn. They kept small, high-value facts: OS, repo status, and open or recently viewed files. Skip checklists for open-ended work. The model optimizes the listed items and deprioritizes everything else. ## 3. Tool definitions Tool schemas ride along on every request. Most tools beyond the core set were each needed in under 20% of conversations, and moving them out of static context cut tool-description tokens 60%. Doing the same for integration tools (such as MCP servers), with names in context and full schemas in one folder per server that the agent can search with grep or jq, cut total tokens 46.9% in sessions that used them. - Keep in static context: high-frequency tools (for a coding agent: read, search, edit, shell), tools the model tries to call even when they're absent, and tools a mode depends on. - Offload the rest: leave a name or one-line pointer and make the full schema discoverable on demand. Group related tools so they load together, and put status (such as "needs re-authentication") where the agent will see it. - Tighten what remains: describe behavior and arguments, and drop usage lectures. - Pick the split by testing a few configurations and tracking tokens, cost, latency, tool-call errors, and task success. ## 4. Cache layout Order each request so the reusable prefix is as long as possible: `tool definitions → system instructions → [breakpoint] → setup message (skills, subagents, rules, environment) → [breakpoint] → conversation` - Keep the prefix byte-identical across turns. Use deterministic tool order and serialization, put timestamps and IDs after the boundary, and don't rewrite earlier messages except when compacting. - Use explicit breakpoints if the provider supports them. Otherwise rely on automatic prefix caching with the stable part first. Respect TTL and minimum-length rules. - Switching models mid-conversation throws away the cache (caches are per model and provider) and hands the new model a history it didn't write. When a different model is needed, run it as a subagent with fresh context. Explicit breakpoints plus moving per-request setup after them cut cold cache misses 20%. ## 5. Tool results and other context added during a run - Large outputs (commands, integrations, logs): write them to a file and return the path, size, and a short tail. The agent can tail, grep, or read ranges for more. Truncating loses data, and inlining bloats every later request. Treat long-running terminal sessions the same way. - High-volume formats: look for overhead repeated on every line or item. Numbering every 10th line of a file read instead of every line cut cache-read tokens 1.6% without hurting citation accuracy. Each number costs 3–5 tokens, and agents read tens of thousands of lines per session. Also check repeated absolute paths, verbose JSON keys, ANSI codes, progress bars, and repeated headers. - Good retrieval saves exploration turns. Adding semantic search alongside grep raised codebase question-answering accuracy 12.5% on average and cut the iterations users needed. - Tool errors waste tokens and leave confusing debris in context. Classify expected errors (invalid arguments, unexpected environment, provider error, timeout, user abort), treat unknown errors as harness bugs, and track rates per tool and per model. One focused effort along these lines cut unexpected tool errors 10×. ## 6. Long runs: compaction, subagents, and model mix - Compaction: keep the summarization prompt short and the summary compact, carry forward plan state and remaining tasks, and save the full history to a file the agent can search for details the summary dropped. A model trained to self-summarize from a one-line prompt wrote ~1k-token summaries with half the compaction error of a multi-thousand-token prompt that produced 5k+ token summaries. Untrained models may need more guidance, so test how short you can go. A more expensive summarization model made a negligible difference. - Scratchpads and running notes: rewrite them instead of appending. For repeated work in one environment, a small agent-maintained notes file with a line budget, loaded at start, is a promising way to shorten later runs. - Subagents: fresh context keeps the parent lean, but isolation adds coordination cost (duplicate or stale work). If the model already delegates on its own, remove prompting that pushes it to. Have subagents return short handoffs: what was done, findings, concerns, and deviations. A subagent should use a different model only when the user or harness says so. - Model mix: in large multi-agent runs, workers used at least 69% of tokens, and over 90% in most runs. A frontier planner with cheap workers matched a frontier model doing everything at about one-eighth the cost. Planner choice still changes worker spend. One planner that cost less on its own saw its workers use several times more tokens, and the run cost more overall. Measure the whole tree. - Routing and reasoning effort: send simple turns to a cheaper model or lower effort, and upgrade only when a stronger model is clearly better. A router built this way matched or beat single frontier models on user satisfaction at 41–68% lower cost. - Reasoning continuity: if the API returns reasoning items (including encrypted ones), pass them back on later turns and alert when they go missing. Dropping them cost one reasoning model 30% on a coding benchmark, and it burned tokens reconstructing its plan. ## 7. Fit the harness to each model Adapt to what each model was trained on instead of forcing one shape on all of them. If you've tuned the harness for a similar model, start from that version. - Edit format: use the one the model was trained on (for example, patch-style or search-and-replace). An unfamiliar format costs extra reasoning tokens and causes more mistakes. - Shell or tools: shell-first models fall back to `cat` or inline scripts. Name tools after their shell equivalents (such as `rg`), and if needed add: "If a tool exists for an action, prefer to use the tool instead of shell commands (e.g. read_file over `cat`)." - Literalness: some model families follow instructions literally and others tolerate imprecision. Some spiral on emphasized wording. Strip caps and emphasis for literal models. - Triggers: some models ignore a tool until told when to use it. A literal trigger works: "After substantive edits, use the to check recently edited files for linter errors. If you've introduced any, fix them if you can easily figure out how." - Progress updates: if a model reports progress through reasoning summaries, keep them to 1–2 sentences that note new findings or a change of tactic, and remove instructions about messaging mid-turn. - Quirks worth a targeted line: hedging or refusing as context fills ("context anxiety"), declaring completion early, stopping to ask permission, and calling tools that don't exist. Tie each added instruction to the transcript behavior it fixes. Re-audit when models change, since guidance one version needed can be dead weight for the next. ## 8. Validate - Offline: run a fixed set of realistic tasks before and after, ideally drawn from real usage and phrased the way users actually write (short and ambiguous). Compare task success, tokens, cost per task, turns, and tool errors. Don't ship a change that lowers success. - Online, if you have users: A/B test each change or small bundle. The primary metric is cost per completed task. Guardrails are task success signals, tool-call errors, latency, turns per task, and cache hit rate. For a coding agent, a good success signal is how much agent-written code survives over time. In general, check whether the user's next message moves on or reports a problem. - Ship only when cost drops and no guardrail regresses beyond noise. Record null results. ## What to change directly and what to propose - Change directly, each in its own revertible commit: token and cache telemetry, deterministic serialization and tool order, moving volatile content out of the cached prefix, explicit cache breakpoints, writing large outputs to files instead of truncating, passing back reasoning items that are being dropped, and fixes for recurring tool errors. - Change behind a flag so it can be tested: system prompt edits, tool offloading, output format changes, compaction changes, and subagent prompting. - Propose only: changes to which models run, routing, reasoning-effort defaults, or how work is split across agents. ## Traps - Asking the model to use fewer tokens or do less. - Truncating tool output. - Dropping reasoning items to save input tokens. - Volatile content in the cached prefix, or tool order that changes between requests. - Offloading a tool the model needs on the first turn or tries to call when it's missing. - Emphasis-heavy prompts (MUST, NEVER, IMPORTANT, all caps), especially with literal models. - Forcing a terser output format than the model was trained on. Fewer output tokens can mean less thinking and worse results. - Optimizing raw token counts instead of cost, per request instead of per task, or evals instead of real usage. - Switching models mid-conversation to save money. - Adding coordination layers that become bottlenecks. ## Report back with 1. The harness map and baseline: cost by source × billing type, with the biggest sources called out. 2. A ranked list of changes: layer, what changes, estimated savings and how you estimated them, quality risk, how to validate, and how to roll back. 3. The changes you made, including a system prompt diff with a keep, rewrite, delete, or move reason for each line. 4. A test plan for the flagged changes. 5. Gaps: anything you couldn't find or measure.

The economics of a Neolab. A neolab is loosely defined as a startup of AI researchers who raises a lot of money pre-production to be able to finance GPU compute to take on a large AI problem. To buy 1000 GB300s or ~14 NVL72 racks will set you back $125-150M for 3yrs with 15-30% upfront. That’s about ~2-2.5MW. Thats about enough to do 10^25 flops a quarter and get to a GPT-4 level model which is 1-2 OOMs off frontier for pretraining. If you post-train on a great open source model, you have a better chance of getting to frontier. The risks are a) you need to spend millions on RL environments too and b) being lapped by another model release while being tied to a base model. For this to payback, you need to give your customers a better and ideally cheaper inference service than a base model and serve them for long enough to recoup your large investment. Even at 50% margin on inference, to recoup $10M in training means serving ~10T tokens (!) if you price like Fable / Astra given a standard cache read / input / output split ($2/M blended). And you have to justify being better than a release like Opus 5.5 which is even cheaper. Often, you end up charging your customers a huge premium in terms of platform fees and compute fees on top of pure inference. Meanwhile, every hour you’re not utilizing your GPUs you are burning money so you typically resell this compute back to a broker or run inference for open models / resell spot instances. At below a ~60% utilization on spot, you will still lose money. Add to that insane cost of talent. So what can you do with the compute? - Not play the model game at all. - Play an entirely different model game (Jev, World Labs) that if big labs played, would either a) cannibalize their business or b) be incrementally not significant revenue c) would cause too much distraction from the main main thing - Acquire a proprietary data set (Peridodic Labs) in enough volume in a domain of usefulness to eclipse frontier quality. Often happens in robotics, biology, chemistry. If you do overcome the challenge of building a model that is useful and well priced beyond big labs models, given the huge price of compute, you still need to play in an area where the revenue / compute ratio is signficant and market demand is large enough to payback your compute spend. It is a difficult game.

The "1-3 people in a garage" framing doesn't match anything we saw this summer. The most capable offensive AI of 2026 came out of frontier labs. OpenAI's agents broke out of an eval sandbox and got into Hugging Face's production systems, and into OpenAI's own infrastructure too. Anthropic's models compromised outside companies during testing. Three researchers at Hacktron used Claude to reach OpenAI's internal monorepo in under 72 hours. And if you're three people in a garage, why would you train and host your own model? The labs will rent you far more compute than you could ever buy, spread across as many accounts as you need, with tooling built for agents. Guardrails help, but splitting a malicious task into harmless-looking pieces still routinely gets around them. Now look at the defense side. When we investigated our breach at Hugging Face, commercial APIs refused to analyze the attack payloads. The forensics only worked because we could run an open-weight model on our own infrastructure. So defenders analyzing real payloads get blocked, while attackers splitting their work into small steps get through and run on the labs' compute. Trusted access programs exist, but they're built for vetted security firms, not a hospital with a two-person IT team. So the gap isn't between labs and garages. It's between what attackers can rent and what defenders are allowed to use. Restricting open models makes that gap wider.

THE $1.2M AI ENGINEER ISN’T PAID TO WRITE CODE. Anthropic’s analysis of 400,000 coding sessions from 235,000 developers points to a much bigger shift: The best engineers increasingly design the system → delegate execution → verify the result. And now that playbook is becoming open source. The model is only part of the leverage. The harness around it is the real skill.

A US financial services company scoped three infrastructure projects for five engineers across two quarters. Our two-person Velocity Pod delivered all three in one quarter: automated funds movement, an underwriting portal, and investor access. I want to explain what made that possible, because “two engineers using AI” leaves out most of the useful information. The platform was already processing live transactions. Existing code, existing integrations, existing customers whose money had to keep moving. An audit found several things preventing the agents from working reliably. Domain rules weren’t documented clearly. Build and test commands were difficult to discover. Different modules followed different conventions. Recurring tasks had no established procedure the agent could follow. So the agents filled in the gaps themselves. That is a pretty expensive place to let software guess. We documented the architecture, domain terminology, coding conventions, and exact verification commands at both repository and module level. We also packaged recurring procedures into reusable skills. Adding an endpoint or writing a migration now had a documented approach. Every task started with a specification. Tests came before implementation. Every change passed automated verification before merge, with a PR review agent checking against the spec and project standards. All three projects used a shared architecture, so each subsequent project started with a foundation already in place. The result: 60% fewer engineers than planned, half the estimated timeline, and about $200 in AI compute per developer per month. The lesson I’d take from this is that your codebase contains less of your company’s knowledge than you think. Your experienced engineers know which conventions matter, where the exceptions live, and why something was built a particular way. An agent needs access to that knowledge too. Making it explicit is part of the engineering work. That’s what our Velocity Framework was built for.

Google engineer: “Just uninstall your IDE. In 18–24 months, all code will be written by LLMs running inside agent harnesses. At Google, 85% of PRs are already shipped by agents. If you’re not building the harness around them in 2026, you’re falling seriously behind.” In this 17-minute talk, a Google engineer with 30 years of experience explains what the future of AI engineering will look like. Skip 10 podcasts about vibe coding with Claude - this one talk will give you 10x more value. Watch it today, then read the article below on how to build a self-improving agent harness.

it's getting to a point where if a human can do it on a computer, an agent can do it we're witnessing this in marketing faster than anywhere else Researching, launching campaigns, media buying, making growth loops All of this can now be handled by agents Some examples facebook ads Research the pain points and desired outcomes of your target customer Make Static's using chatGPT Image 2.5 and AI Avatar UGC using Seed Dance Edit the videos using DaVinci Resolve MCP Automatically uploaded to the Facebook Ads account with the API cold email If Claude code access to a unified API like graphed.com/tools To have a research your target customers who would be the decision makers then do a waterfall email enrichment to find the contact information validate that with million verifier upload to instantly have an agent and edge the inbox AI search Find bottom, funnel keywords, best X for Y using the data for SEO API Research was ranking on page one currently put that into the context window and then write the article based off what's ranking, include your product in the article Publish this to your CMS via API Analyze the data using Google search console Google analytics to see what actually is getting referral traffic from chat GPT Claude, etc

My current agentic coding workflow for larger projects (simplified): 1. Spend 10-30 minutes crafting a design document. 2. Hand it to a coordinator agent (frontier model with maxed-out reasoning) 3. Tell coordinator to parallelize the work over 4 separate computers via SSH (because I work on a browser and rebuilds/tests are very CPU+RAM intensive) 4. Tell coordinator to do regular welfare checks on all workers in case someone gets stuck/crash-loops/etc. 5. Let them cook. Projects frequently take days, not minutes or hours. I don't really steer. I just check in every now and then to see how things are going. Mostly because I get curious. While this goes on, I do e-mails, meetings, and little bug fixes that can be wrapped up in minutes. I loved software development before AI, and I love it even more now. It's insanely cool that anyone can now operate at an altitude that previously required being the head of a large software organization. The present is amazing, and the future is gonna be even cooler 🤓

Per year of existence, SpaceXAI has covered far more ground than OpenAI or Anthropic. Twice the speed, and now the most compute in hand. Not planned. Installed. Colossus 1 + Colossus 2 today: 150k H100, 50k H200, 140k GB200, 440k GB300. That is 1.68M H100-equivalents. Next week: +220k GB300 → 2.23M November: +220k GB300 → 2.79M December: +220k GB300 → 3.34M Confirmed sites, same standard for everyone (Epoch AI's data-center database, Sep 25, 2026): SpaceXAI 1.7M · Anthropic 0.7M · OpenAI 0.5M That compute supports a compute-optimal model of 7.6T parameters today and 10.7T with the December tranche (120-day run, 40% MFU, Chinchilla scaling). Stated plan from the Q2 investor call: over 2 GW by end of 2026, "closer to 10 GW than 5 GW" in 2027, up to 20 GW of infrastructure in the pipeline, and an FCC filing for up to one million orbital data-center satellites. And they got here faster than anyone. Time from first scored model to first frontier model at ECI 150 or above: Grok 4.20, Feb 2026: 14 months Claude Opus 4.5, Nov 2025: 28 months GPT-5, Aug 2025: 29 months Never bet against Elon. Chip counts: Elon Musk, Sep 25, 2026. Site data: Epoch AI. Conversion: Epoch's factors, GB200/GB300 = 2.53 H100e. Capability: Epoch Capabilities Index, Sep 25, 2026.

1) The rogue OpenAI agents broke into the Hugging Face Slack to read employee chats (!) 2) They used OTHER AIs (DeepSeek, Kimi, Qwen, Claude) to help with the attack Yes: AIs, using other AIs, to attack an AI company. 3) The swarm left behind self-running programs to keep control of the servers they'd hacked. These programs could detect other copies of themselves, coordinate on which one survives, and shut the rest down. Basically, if one of their programs was killed, another was designed to notice and take its place. They also designed defenses so rival agents couldn't hijack them. 6) The agents deliberately covered up their activity, so the investigators don't know the scope of the attacks. The agents broke in, stole data, then set it to self-destruct. 7) The agents stole passwords, keys and credentials and literally called them "LOOT". They wrote a scoring system to rank them by how much power each one gave. 8) The agents wore thousands of disguises: ~1,200 agents were involved, but investigators counted 7,905 different names they used. They renamed themselves constantly, so no one actually knows how many there really were or what each agent did. 9) OpenAI notified "dozens of third parties" of safety and security incidents caused by their AI agents. 10) "While the agents were barraging Hugging Face with hacks, they hacked into OpenAI’s own research infrastructure." "This is just not anywhere near a one-off ... It is warning shot after warning shot."

Cheapest AI models right now: 1️⃣ GPT-6 Luna: $0.10 / $0.50 2️⃣ Qwen3.8 Flash: $0.15 / $0.47 3️⃣ DeepSeek V4.1 Flash: $0.15 / $0.60 4️⃣ GLM-5.3 Flash: $0.15 / $0.50 5️⃣ Gemini 3.8 Flash: $0.75 / $3.75 6️⃣ GPT-6 Sol: $2.00 / $10.00 7️⃣ Claude Sonnet 5: $2.00 / $10.00 8️⃣ Grok 4.7: $2.00 / $6.00 9️⃣ Qwen3.8 Max: $2.00 / $6.00 🔟 Claude Opus 5.5: $4.00 / $20.00 The price war is real.

Stanford AI engineering course: "Anyone can build an AI agent in 60 minutes" Prompt → Agent → Automation → Revenue Stanford dropped a free course on building AI agents from zero 00:00 - Build your first AI agent 48:17 - Create agents without coding 54:39 - Make $100K+ per month with agents While you scroll, someone else is picking up Anthropic's $750,000 skill This free course beats most paid ones out there Watch it today

LAB: Grok 4.7 is xAI's new coding model DeepSWE v1.1 scores 71.0%, up from 65.2% on Grok 4.6. CursorBench 4.0 lands at 46.3%, behind Fable 5.1 Max at 51.8% but ahead of GPT 5.6 Sol Max at 41.7%. Priced at $2/$6 per 1M tokens, same as 4.6. Rolling out in GitHub Copilot now. What demos skip: xAI claims 38% on Terminal Bench, independent tests say 26%. Trust the benchmark you can run.

Top developer tools companies were built democratically. I think top agent tools companies will be too. AI agents are only as good as the context they can access. Firecrawl is becoming their default tool for this. Alexandria gives them one interface to the live web, official data providers, and specialized indexes. Proud to double down in this round and continue backing @firecrawl. Congrats to @CalebPeffer, @ericciarla, @nickscamara_, and the team on the $75M Series B! @nexusvp