Daniel Braz @dsbraz
IA, coding, technology & science - CTO @brqdigital dsbraz.com São Paulo, Brazil Joined July 2009-
Tweets3K
-
Followers159
-
Following2K
-
Likes6K
The agent orchestration choice is not "model-native or framework." There are three places, not two. In my last piece I drew a line with two ends. On one end, the model orchestrates inside its own reasoning loop. On the other, you build the orchestration in your own code. Anthropic shipped Dynamic Workflows with Opus 4.8. And it lands in the middle. The middle I had left empty. Dynamic Workflows is orchestration that lives in the product runtime. Outside the model. Outside your code. That opens a third control boundary: — Model-native (Kimi Agent Swarm): the boundary sits at the edge of the model. The verifier is just one more agent. — Runtime-managed (Dynamic Workflows): the boundary sits at the edge of the product. The verifier is an external gate you already trusted (the test suite). — You build it (LangGraph and friends): the boundary sits at the edge of your code. The verifier is whatever you encode. The clearest way to feel the difference is to ask each one the same question: how does the system know it got the work right? A note on honesty. I use Claude in production. That is exactly why I need to be clear: there is no independent evaluation yet of how Dynamic Workflows behaves under stress. The swarm numbers have been stress-tested by third parties. The runtime ones have not. Treat the comparison as design intent, not a verdict on reliability. The map gained a point. The advice did not change: choose based on where the control boundary needs to sit. There are just three places to put it now. medium.com/@dsbraz/three-…
Fable 5: @AnthropicAI just turned governance into a product Today Anthropic released Claude Fable 5, its most capable model ever made available to the public. It leads almost every benchmark, and Stripe used it to do in one day what would have taken more than two months of engineering. All true. But that's not what I want to talk about. Anthropic didn't ship one model today. It shipped two. Alongside Fable 5 came Mythos 5. They share the same weights and the same capability. The difference isn't in what the model can do — it's in who gets to use it. Mythos 5 stays restricted to approved partners. Fable 5 is the same engine, but with a safety layer switched on: when you ask something about cybersecurity, biology, or chemistry, it reroutes the question to Opus 4.8 and gives you a more limited answer. In other words, the capability in the headlines belongs to the model that's locked away. What you can actually buy is the version with the brake on. This goes beyond a technical detail. For years, capability and delivery were the same thing: you trained a better model and it went out the door to everyone. Today Anthropic split the two and put a layer in the middle that decides, in real time, which model you get to reach. Governance became the product. The model became a prerequisite. This is what I've been saying: the bottleneck for AI in the enterprise was never the model's capability. It's implementation. For anyone operating in Brazil, this sounds familiar. No serious company under LGPD, Bacen 4658, or ANS rules ever had the model as the hard problem. The hard problem is everything around it: what can be answered, what needs a human in the loop, what needs an audit trail, what can't leave the perimeter. That harness was never an accessory. It was the solution. And Anthropic has just turned it into a product — and is charging twice the price for it. If your strategy depends on having access to the most powerful model, today is a good day to rethink it. The most powerful one isn't for sale. The advantage that lasts isn't in which model you call — it's in the layer that decides how to call it. Capability rents by the token. The harness that separates a pilot from a production system is something no one hands you ready-made through an API.
EDITORIAL | Caso exemplar de ativismo judicial – “Ao transformar uma condenada por omissão gravíssima em vítima, Elizabeth Louro foi mais uma magistrada a expor o perigo de uma Justiça militante”. Leia o texto completo em x.gd/dNiaL via @opiniao_estadao)
EDITORIAL | Lula quebra o Brasil para se reeleger – “Somente neste ano foram 33 medidas, somando a marca de R$ 215 bilhões em aumento de despesas ou redução de receitas. Pelo visto, o governo Lula perdeu a pouca vergonha que ainda tinha”. Leia o texto completo em x.gd/4w5qA
.@McKinsey says the CTO has become a builder. Reorienting the function from managing technology to building market-ready capabilities. I agree. But I want to add a point to this conversation. Almost everything written about building technical capability assumes a product company. A central platform team that builds the reusable foundation product teams consume. In services it's different. Every deal is unique, customized to the client's demand. There's no generic foundation that serves everyone by design. So the question becomes: how does a platform team work in a services company? The answer I've been testing is the forward-deployed model. Instead of a central lab, you advance the engineer who owns the accelerators into the client's problem. They carry two objectives at once. Deliver the solution. And come back with what they learned, to improve the asset. It's the same engineer who builds the tool, takes it to the field, and brings it back better. The asset only evolves because whoever operates it understands the work deeply. Tacit knowledge isn't transferred through documentation. It's transferred through proximity. And here's the part most people get wrong. The differentiator is never the tool. Today it's agents. Tomorrow it'll be something else. Whoever bets on the tool becomes obsolete when the wave turns. The differentiator is the ability to see which wave to ride before the market does — and to operate it first. The tool is the means of the moment. The vision is what lasts. The builder CTO, in a services firm, isn't the one with the best agents. It's the one who keeps the firm a viable partner wave after wave.
Most agent frameworks run one model instance through a loop. It works for sequential tasks. It breaks when the work has parallelizable subproblems that demand different specializations. The standard answer is external orchestration. LangGraph, CrewAI, Python workflows. You design the graph, the state transitions, the retry logic. Full control, engineering cost. Kimi K2.6 makes a different bet. It embeds swarm orchestration inside the model itself. Up to 300 sub-agents in parallel, decomposed and aggregated inside the reasoning loop, not in the code you write. But the point is not the agent ceiling. It is where the control boundary sits. Native orchestration: one API call, one synthesized output, zero infrastructure. And zero ability to audit the coordination logic. External orchestration: full control of the graph, every turn logged and inspectable. The cost is building and maintaining that layer. It is not about which is universally better. Teams that need to explain agent decisions — to auditors, to security reviewers, to the colleague debugging the failure — will find external orchestration's transparency enough to justify the setup. Teams that need to move fast on parallelizable tasks will find the swarm's convenience hard to beat. In our own agent platform we see the same pattern. Native orchestration works well for bounded, parallelizable workflows. External orchestration is necessary when an agent's decision must trace back to a specific business rule. Choose based on where you need control, not on what is newer. medium.com/@dsbraz/kimi-a…
Leiam @fernandoschuler
prompts are technical debt. but not every prompt is the same debt. @sjgoedecke argues prompts are a worse form of technical debt than code. the argument is good: prompts are model-specific, and what worked on GPT-5.4 won't work on GPT-5.5. worse, they decay silently. broken code throws errors. a stale prompt just makes the model a little dumber, and you never notice. his prescription follows the diagnosis: use a third-party tool, leave it unconfigured, avoid MCP and skills, delegate the tuning to teams that re-evaluate prompts every release. i agree with the diagnosis. i disagree with the single conclusion. the mistake is treating "prompt" as one layer. it's two. the first is behavior steering. "think step by step", "you are a senior engineer", "i'll tip you $200 if you get it right". this is pure coupling to the model. this is where the debt sean describes lives. delete it. delegate it. fully agree. the second is theory about the system. concrete facts about the project, domain constraints, architecture decisions, the why behind things. this isn't model tuning. it's Naur's theory written down as text. it doesn't decay when the model changes, because it doesn't talk to the model. it talks about the system. an AGENTS.md full of concrete facts ages at the same speed as the code it describes. slowly. the harness is where these two layers blur. which is exactly why human judgment needs to be more present there, not less. the practical rule: treat behavior steering as high-interest debt — minimize, automate, outsource. treat system theory as code — write it yourself, review it, keep it lean. sean's advice to "write your prompts and delete them whenever you can" holds perfectly for the first layer. for the second, deleting is losing knowledge. the right question isn't "how much prompt do i write". it's "which of these lines talks to the model, and which talks about my system". seangoedecke.com/prompts-are-te…
.@AnthropicAI shipped Opus 4.8 last week. Everyone's talking about the benchmarks. I want to talk about Dynamic Workflows. The model can now coordinate hundreds of parallel subagents — plan the work, fan it out, verify the outputs, report back. Anthropic's own example: codebase-scale migrations across hundreds of thousands of lines, kickoff to merge, with the existing test suite as the bar. Here's why that matters more than another point on a coding eval. For two years we've been bolting orchestration onto models from the outside. Every serious agentic team built the same scaffolding: a planner, a dispatcher, verification loops, state that survives context degradation. That scaffolding is the harness. And the hard-won lesson is that the harness, not the model, was carrying most of the reliability. Dynamic Workflows pulls a chunk of that harness into the runtime. Planning, parallel execution, self-verification — capabilities we hand-rolled — now sit closer to the model itself. That's not a threat to harness engineering. It's a clarification of where the work moves. When the runtime absorbs orchestration, the engineering doesn't disappear — it climbs the stack. The questions get sharper: what do you delegate to the runtime versus keep under explicit control? Where does human judgment stay in the loop on irreversible actions? How do you verify the verifier? The platform still needs a spec, a contract, observability, a way to reason about failure under long-horizon stress. The model getting better at orchestration raises the ceiling on what the platform around it has to be. The teams that win the next year aren't the ones with the cleverest prompt scaffolding. They're the ones who understand which layer of the harness just became commodity — and move their effort up to the layer that didn't. What part of your harness do you think the runtime takes next?
Every team shipping agents to production hits the same question: where is this agent today, and what do we build next? The models we already have answer other questions. Level ladders (L0–L5) give a shared vocabulary. @karpathy's autonomy slider designs the product surface. @OpenAI's levels point to where the technology is heading. All useful — none answers the operational, day-to-day question. That's the problem, because maturity for an agent isn't a single variable. It's the composition of several independent ones. A system can be highly autonomous on one axis and deeply fragile on another — and the gap between "works in a demo" and "works in production" almost always lives in those gaps between axes. In the article I propose six dimensions I've been using for the last eighteen months with product and engineering teams: - Task structure: how decomposable the problem is into stable steps - Verification cost: the single most predictive variable for where agentic patterns succeed - Reversibility and blast radius: what an error touches, and whether it can be undone - Loop speed: Karpathy's metric for partial autonomy - Context persistence: how long context needs to survive, and how reliably - Failure-mode tolerance: what happens, in practice, when the system is wrong It's not a score you aggregate into a single number. It's a profile: six positions, read together. And the pattern that repeats most when I overlay the framework against real agents in production: the gap between what works and what doesn't is rarely the model. It's the harness. The question stops being "what level are we at?" and becomes "which dimension, if we moved it, would change the system the most?" Full article: medium.com/@dsbraz/six-di…
Mathematician solved a problem that had been open for 42 years using ChatGPT. My first instinct was "ok, AI does research-level math now." After listening to the episode, I think that's the wrong read. What @ErnestRyu describes on the OpenAI podcast (with @SebastienBubeck) is a division of labor. @OpenAI's ChatGPT sweeps the literature, suggests connections, sketches proof skeletons. He still does what no model does on its own: pick which problem matters, sniff out when a proof is quietly wrong, decide whether something is deep or just convincing. They touch on a point I think goes well beyond math — the risk of shallow understanding. The model hands you a clean answer, and if you don't have the judgment to check it, you take it. The pairing works because the human knows how to verify. It's not replacement. It's a pair where each side does what it does best. Anyone working with agents in any field will recognize the pattern. 🎧 open.spotify.com/episode/7zijNX…
The agent builder is not the platform. It's an authoring surface on top of it. Sounds like a pedantic distinction — until you try to migrate vendors. When a company buys an "agent builder," it's usually buying a layer 7 wired into someone else's layers 1 through 6 — and inheriting that vendor's choices about runtime, context engineering, tool plane, memory, orchestration, and governance. Usually without realizing those choices were made. In the new piece I unpack the anatomy of an agentic platform into six layers, in the order they load at runtime, and place the agent builder where it actually belongs: at the top, as one surface among several. The core claim: code-first, config-first, visual, and generative — the four authoring surfaces emerging now (@wonderful_ai's Agent Builder, @SierraPlatform's Ghostwriter, and what's coming next) — should all produce the same AgentSpec, consumed by the same runtime. When they don't, you have four disconnected products pretending to be one platform. That's exactly the architectural mistake that makes migration so painful. At @brqdigital we operate our own platform, and these aren't abstractions — they're weekly decisions: what to build, what to buy, and what to own explicitly because owning it is the product. The agent builder, done well, is the last thing you build. Not the first. medium.com/@dsbraz/the-an…
Starting every AI conversation from scratch is a quiet waste. You know the drill: open a new window, paste your style guide, explain who you are, summarize the project, recap what you discussed yesterday. Then do it all again tomorrow. We've all grown tired of this. And that's why some interesting solutions have been popping up. One of them is what @koylanai calls Personal Brain OS: a personal file-based operating system inside a Git repository. What this means in practice: * Progressive disclosure: the AI loads context in layers — general instructions first, then specific modules, only when needed. * Isolated modules: identity, content, knowledge, network, operations, agents. Each gets its own file. * Append-only memory: JSONL logs that only grow, with a defined schema, easy to parse. * Zero database: everything is a text file. Git handles versioning. The result? You stop retelling your story every time you open a prompt. The AI already knows who you are, what you want, and how you think. This reminds me of something I've been saying: the bottleneck in using AI today isn't the model, it's context. The more time you spend reintroducing information, the less time you spend creating. A system like this isn't about having more tools — it's about stopping stating the obvious. His repo is open and works as a practical reference, not just a concept. Worth checking out if you use Codex, Claude Code, Cursor, or any agent that reads local files.
Rings topology
I've been talking about Digital Workers for a while — not as automation with a fancy name, but as agents that hold real positions in real teams. The concept is simple: defined scope, ownership of processes, continuous evolution. What was missing was an implementation that simplified things and let you move fast past the POC. I think @_HermesAgent (from @NousResearch) points in that direction. Today we implement Digital Workers (here at @brqdigital) as custom agents, built one by one. Not because we lack ready-made platforms. But because we need fair governance — knowing exactly what the agent does, why it does it, and how to audit it — and because processes are highly varied. Each role demands custom skills and tailored connector chains. Too much genericity here is a risk, not scale. The problem is that this custom model doesn't scale well. Every new Digital Worker requires engineering from scratch. What interests me about Hermes is that it flips this logic: instead of me writing every skill manually, the agent executes complex tasks, creates skills from experience, improves those skills during use, and persists knowledge across sessions. It retrieves past conversations, summarizes trajectories, and builds an increasingly precise model of who you are — especially when paired with @honchodotdev (from @plasticlabs) for dialectical user modeling. What would this change in practice? Today, when an agent hits a gap in the process, it stops. Someone has to write new code. With this architecture, the agent would create a new skill, test it, refine it. Memory wouldn't be a static database — it would be a living model that enriches with every interaction. This is what separates a DigitalWorker from traditional automation: the ability to evolve within scope without depending on a human to rewrite rules. Hermes runs wherever you need it — $5 VPS, GPU cluster, serverless — and talks to you via Teams, Telegram, Slack, Discord, WhatsApp, Signal, or CLI, all from a single gateway. But the point isn't the stack. It's the behavior it enables: an agent that assumes a function, develops competencies for that function, and improves on its own. We're not there yet. Today it's still custom, one by one, by conscious choice. But the question I ask myself is: what if the next role on our team didn't need a human rewriting rules and connectors every time the process changes?
Agents didn't repeal the laws of software engineering. They intensified them. Wrote about this on Medium. The core idea: AI tools shift the dynamics, but they don't cancel out principles that have governed development for decades. A few things I explored: - Inverted Postel's Law: with agents, you send more context than usual (liberal in what you send), but need to be stricter reviewing what comes back (conservative in what you accept). - Brooks' Law challenged: multiple agents working in parallel can, under certain conditions, speed things up instead of slowing them down — as long as there's robust automated verification. - Conway's Law in a new dimension: each person's prompting style becomes a silent "organizational structure." This can fragment the codebase in ways we're still figuring out how to manage. The point isn't "AI changes everything" or "AI changes nothing." It's that the same laws still apply, only now they operate at different speed and scale. And that brings new problems along with the gains. If you're writing code and experimenting with agents, you'll recognize some of these tensions. Full article: medium.com/@dsbraz/agents…
I tested Kimi. It works. I've been using AI for years. I've seen a lot of things that promise and don't deliver. I tested Kimi with real projects. No demos, no toy prompts. Slides: I fed it a dense document. Expected a summary in boxes. Got a presentation with clear argumentative structure — the model understood the logical progression, not just dumped text into slides. Only needed to adjust when the source document had ambiguous priorities. Agent Swarm: I've seen "multi-agent" that's just sequential calls. Kimi's Swarm actually parallelizes, with agents reviewing each other's work. One caught a data discrepancy I would have missed. Sometimes too conservative in decomposition, but I'll take that over inconsistency. Code: I passed a complex mockup. Got working React, not a skeleton with TODOs. Pointed out a visual discrepancy, it fixed and validated on its own. Works well for UI/UX. For complex state architecture, still needs human input. I still prefer Codex. Claw: Still testing. Want to see how it handles long workflows before I have an opinion. Summary: Not perfect. Has limitations. But better than average at three things: structural inference, agent coordination, and execution fidelity in code. For anyone who's been using AI for a while, it's real evolution, not just hype.
Caught Bender's I/O 2026 talk — Software engineering at the tipping point. Worth a watch. One point that stuck with me: once agents are running internally, every internal API is effectively public. Agents don't negotiate access — if they can get to the data, they will. youtube.com/watch?v=2n41Yj…
In 20 minutes I had an ops agent running on LangSmith Fleet. A week later, it broke. And that's the interesting part of the story. Not because Fleet failed — it did exactly what it promises: OAuth, Calendar/Gmail/Slack integrations, schedule, delivery. All in minutes, no code. But email triage was inconsistent. Drafts came out too generic. The 8 AM cron didn't fit every day. That's the architectural point that matters: when does no-code stop being sufficient — and what do you do next without reinventing OAuth from scratch. I wrote a full case study of the hybrid architecture we ended up running. Fleet as the integration layer, LangGraph for orchestration, LangSmith for observability. With code, decisions, and the three insights that only surfaced once I started reading the traces — including a redundant Gmail search that was consuming 40% of execution time. medium.com/@dsbraz/buildi…
mohdtakyuddin @mohdtakyuddin
94 Followers 3K Following
Patricia leon @PatriciaLe84652
43 Followers 2K Following
Gabriel Gonçalves @gabgforge
3 Followers 23 Following Building SpecForge — AI agent orchestration that ships real software. OSS format. Electrical engineer → self-taught dev → AI agent factory 🇧🇷
Laurent Denoue @ldenoue
1K Followers 2K Following AI Research engineer – Building apps like Scribe Instant Transcrips, VoiceView, ScreenRun – MTB 🚵 🏔️
Andrei Maxwel @andreimaxwel
500 Followers 2K Following Product Manager | Driving integration strateg through Platforms, APIs, and Automation.
. @SotaOnChainn
80 Followers 602 Following CEO: @StartaleGroup (@StartaleGroupJP) 世界のオンチェー ン化を進めています。英語アカウント: @WatanabeSota ブログ: https://t.co/RrKCmcszUG sota_watanabe
Thiago | Masterclass @thiago_nigrooo
292 Followers 2K Following Masterclass para Iniciantes Aprendizado passo a passo Não é necessário ter experiência Vamos construir sua base
Joseph Chalom @joechalom_
468 Followers 5K Following Co-CEO @SharpLinkGaming (Nasdaq: SBET). Former Head of Digital Assets Strategy @BlackRock. Focused on Ethereum, tokenization and the future of finance.
Matt Haugen @Matt__Haugen
234 Followers 5K Following CIO @BitwiseInvest. Co-founder @FutureProof_HQ. Previously CEO @ETFcom. Husband, father, & runner (when I find time).
Mirko Monti @mirko_monti6
1K Followers 4K Following Currently leading GenAI Product Line in Prometeia - Techno optimist Building towards the pure AI autonomous Company
Wren Mccarty 435JED @435jed83473
0 Followers 230 Following
CamilleMill @359mAl70to2Fy
11 Followers 1K Following
NoraRockefeller @ggTC4x02830xR3M
1 Followers 253 Following
Debby @6y1mSOokS20hM3N
2 Followers 362 Following
Marjolaine Jones @JonesMarjo16164
99 Followers 4K Following
Shewtes @Shewtes5M5slRF
42 Followers 2K Following
Ashlynn Corkery @AshlynnC18926
30 Followers 719 Following
nankiaadilei @nankiaadil53443
5 Followers 106 Following Now really more willingly dress is seeing whatever i m de finibus exit diogenes laertius.
NovaNudge @NovaNudge34855
33 Followers 1K Following
stalderenetet @stalderene67054
0 Followers 73 Following Send back still greater propriety in denmark who it falls out.
Levent @Levent483792036
5 Followers 67 Following
Zeynep @Zeynep1058650
4 Followers 77 Following
Yilmaz @Yilmaz905563514
4 Followers 70 Following
DoreenMill @9s5w3h89htB2v
66 Followers 7K Following
Sapeysea @sapeysea61110
52 Followers 5K Following
Geyroo @Geyroo348984
29 Followers 2K Following
Taslys @Taslys15902
89 Followers 7K Following
Connie_GCVB @ConnieGcvb91941
6 Followers 220 Following
Tertayta @tertayta87971
4 Followers 295 Following
Seighs @seighs57689
17 Followers 2K Following
Geele @Geele224014
15 Followers 2K Following
Thesmeb @Thesmeb179812
35 Followers 2K Following
Tegha @Tegha412379
0 Followers 22 Following
Leila Portella @LeilaPortella1
0 Followers 32 Following
Christoph Windheuser @Windheuser
999 Followers 2K Following Senior Manager Solution Architecture at @Databricks. I am passionate about #BigData, #AI and #MachineLearning. Tweets are my own.
School of Business an... @SBTLondonUK
919 Followers 4K Following School of Business & Technology London is one of the best an online certification courses providers in the UK. #onlinecertificationcourse
Fernando de Sousa Lou... @DrFeLourenco
3 Followers 98 Following Intervindo de forma positiva na vida das pessoas. Atuamos nas áreas Civil, trabalhista e em favor dos funcionários publicos [email protected]
Renato Batista @RenatoBatistaRB
17 Followers 324 Following
Cornell RECYCLING @CornellRECYCLI1
1 Followers 28 Following Here at Cornell we love recycling. we definitely need all your help when campus resumes
fonfix4uOxford @FonFix4u
199 Followers 2K Following FONFIX4U Repair Phone, iPhone Repair, iPad Repair, Samsung Repair, Repair Tablet, Macbook Repair, Laptop Repair, PC computer Repair in Oxford City Center UK.
SagarLongevity @LongevitySFX220
18K Followers 1K Following Want to convince you that Testosterone, Vit D3,C,B12,Magnesium, Zinc and supplements are more important than any other thing like meditation,love,money!
Luciana @LucianaGusSo
13 Followers 162 Following
Ivan Fioravanti ᯅ @ivanfioravanti
38K Followers 1K Following GenAI/LLM addicted, Apple MLX, Cloud computing, Kubernetes, Technology Advisor, Investor and Co-Founder & Board Member of CoreView.
Lilian Rincon @lilianr
10K Followers 813 Following VP of product for Apple AI WW @Apple, Past: Google, Microsoft, Skype 🇻🇪🇨🇦🇮🇩🇺🇸, 🏐, ⚽️, 🎼
Next.js @nextjs
284K Followers 15 Following The React Framework – created and maintained by @vercel.
Kimi Developers @KimiDevs
59K Followers 1 Following The official Kimi account for developers building with Kimi Code and the Kimi API.
Sean Goedecke @sjgoedecke
334 Followers 124 Following
Wonderful @wonderful_ai
815 Followers 23 Following Helping critical organizations accelerate AI adoption. Backed by @IndexVentures, @insightpartners, @BessemerVP, @IVP and @VineVenturesLP
Sierra @SierraPlatform
10K Followers 249 Following We help companies build better, more human customer experiences with AI.
Jarred Sumner @jarredsumner
178K Followers 644 Following building @bunjavascript at @anthropicai. formerly: @stripe (twice) @thielfellowship. high school dropout. npm i -g bun
OpenAI Developers @OpenAIDevs
361K Followers 1 Following Official updates for developers building with Codex & the OpenAI Platform • Service status: https://t.co/kZwnwdYYEq
Lilian Weng @lilianweng
259K Followers 181 Following Co-founder of Thinking Machines Lab @thinkymachines; Ex-VP, AI Safety & robotics, applied research @OpenAI; Author of Lil'Log
Matt Pocock @mattpocockuk
292K Followers 784 Following I teach devs for a living. Author of Total TypeScript and AI Hero. Ex-@vercel. Used to be a voice coach.
Thinking Machines @thinkymachines
156K Followers 1 Following Thinking, beeping, and booping. @tinkerapi
Shane Legg @ShaneLegg
81K Followers 66 Following Chief AGI Scientist & Co-Founder, Google DeepMind Work website: https://t.co/E4SyeGVYXk Personal blog: https://t.co/LL9JNdNpW1
Alex Imas @alexolegimas
32K Followers 2K Following Director of AGI Economics @GoogleDeepMind. Professor at @ChicagoBooth. (on leave) Essays: https://t.co/9qSiQxvdja Opinions are my own.
Theo - t3.gg @theo
346K Followers 4K Following Full time CEO @t3dotchat. Part time YouTuber, investor, and developer
Warp @warpdotdev
57K Followers 2 Following The open-source agentic development environment, born out of the terminal. Build with agents, locally and in the cloud w/ Oz. https://t.co/DhGZnVAeOe
Marcelo Okano @mhokano
302 Followers 591 Following IA - Engenharia de Softwares - Produtividade - Empreendedorismo OKN | DiscoverLabs | OpenAI Codex Ambassador https://t.co/cEEcTRhW3I - Codex Meetup São Paulo
DeepSeek @deepseek_ai
1.0M Followers 0 Following Unravel the mystery of AGI with curiosity. Answer the essential question with long-termism.
Kimi.ai @Kimi_Moonshot
180K Followers 136 Following Built by Moonshot AI to empower everyone to be superhuman. ⚡️API: https://t.co/XCrgjXAqMw @KimiProduct where we share cool use cases. @Kimidevs built for developers
ClaudeDevs @ClaudeDevs
520K Followers 2 Following Official updates for developers building with @ClaudeAI
MiniMax (official) @MiniMax_AI
102K Followers 853 Following Agent: @MiniMaxAgent Token Plan: https://t.co/BDCycxepZw API: https://t.co/fHRdSV7BwZ Community: https://t.co/uhxxfLgkLU
Ben Thompson @benthompson
273K Followers 2K Following Author/Founder of @stratechery. Host of @ditheringfm @sharptechpod. @notechben for sports. @monkbent on other networks. Home on the Internet.
Mario Zechner @badlogicgames
54K Followers 1K Following Armin's handler at https://t.co/B05ybKGkzx. Old man yelling at Claudes. https://t.co/Q1wG57v1yc https://t.co/mnOoWUr0TO https://t.co/8i5vIRE0Wn
Pedro Franceschi @pedroh96
28K Followers 791 Following Founder & CEO @BrexHQ, helping 35k+ companies (from startups to the largest companies on the planet) to spend smarter and move faster.
dex @dexhorthy
21K Followers 2K Following building the post-IDE IDE at https://t.co/9PCpYRSVea - @aitinkerers sf lead, prev @replicatedhq @SproutSocial @nasa - ai that works pod @ https://t.co/69BhaNtWfd
Alec Radford @AlecRad
71K Followers 303 Following
Lior Alexander @LiorOnAI
116K Followers 2K Following Founder @AlphaSignalAI → the Intelligence layer of AI (300k users) • MIT Lecturer • ex-MILA researcher • In ML since GANs
Glauber Costa @glcst
19K Followers 1K Following CEO of @tursodatabase - the next evolution of SQLite. npx turso@latest
Viv @Vtrivedy10
13K Followers 2K Following applied research @LangChain, prev @awscloud, phd cs @templeuniv
Max Brunsfeld @maxbrunsfeld
1K Followers 175 Following @zeddotdev co-founder. Tree-sitter creator. @alissasobo’s husband. Dad of 2. Musician. Boulderer.
Nathan Sobo @nathansobo
6K Followers 240 Following Founder of @zeddotdev, a high-performance multiplayer code editor written in Rust. Formerly a founder of Atom at @GitHub. Father of two special girls.
Alvin Sng @alvinsng
4K Followers 554 Following MTS at @FactoryAI; previously at: Meta, Airbnb, Brex & Opendoor
LangChain @LangChain
254K Followers 158 Following Powering the Agent Development Lifecycle. Makers of LangSmith and @LangChain_OSS and @LangChain_JS.
Thariq @trq212
286K Followers 2K Following Claude Code @anthropicai. prev YC W20, @southpkcommons, @medialab
🍺 Homebrew @MacHomebrew
17K Followers 1 Following The Package manager for Everywhere. This account is mostly unmonitored, sorry! Come talk to us (nicely) on GitHub.
Kot @bunopus_en
3K Followers 67 Following Head of Engineering @jetbrains / Google Developer Expert/ Actually a 🐈/ https://t.co/03i9yzZ1XQ / Second acc: @bunopus
Garry Tan @garrytan
895K Followers 6K Following President & CEO @ycombinator —Founder @garryslist—Creator of GStack & GBrain—designer/engineer who helps founders—SF Dem accelerating the boom loop
clem 🤗 @ClementDelangue
396K Followers 5K Following Co-founder & CEO @HuggingFace 🤗, the open and collaborative platform for AI builders
Harrison Chase @hwchase17
111K Followers 566 Following @LangChain Always hiring: https://t.co/D5Ut3loFO7
Perplexity @perplexity_ai
494K Followers 76 Following Curiosity changes everything. Download our free app on iOS, Mac, Windows, and Android.



















