06-reference/transcripts

indy dev dan fable 5 2 cracked beyond the model transcript

2026-11-16

Your engineering work in your company is not something general. You are solving specific problems, and specific problems by definition require specialized solutions. When anyone can create anything with a single query, the capabilities of the model cease to be your advantage. Imagine two agents on the same model. For example , the new Fable 5.2 model: the first agent is generic. It has standard tools. You use it for every task, and the context window fills up with all the problems you give it. The second agent has targeted tools, targeted context, and a focused system query with all the rules, knowledge, and experience of your engineering team. Spoiler: the goal-oriented agent wins every time, just like the focused engineer wins. Contrary to popular belief, having one super agent do everything for you is not the way to solve specialized tasks consistently, with maximum productivity , speed, cost, and security. So how do you beat a single general agent? You are probably already using

[00:01:00] sub-agents and may have experimented with agent swarms. Both have their own problems . Delegating to sub-agents is good, but the return on real engineering and product tasks is limited. Swarms of agents are incredibly powerful, but they have enormous coordination costs. So where is the “golden mean” between generalized delegation to sub-agents and massive swarms that spend more money than they earn? True multi-agent optimization is small teams of agents. A small team of specialists, each responsible for their own type of work, under the leadership of an orchestrator agent. This is focused, specialized multi-agent orchestration . We will start with an empty factory. Then we will demonstrate a working factory with a real team working on your application 24/7, while you only control the process, not get stuck in it. If you want to understand how a small team of specialized agents can

[00:02:00] solve your problems 24/7, stay with us and we will create small teams of agents in your mini software factory. This is a step forward that you, me, and most engineers don't need unless you fall into one of these three categories. The first category: you write huge 500-line queries that are actually specifications or plans. Second case: you force Fable 5.2 to improve according to the verifiable result in an RSI loop, a recursive self-improvement loop. Or you belong to this third category. This is where it gets really interesting for your software factories . If you need a powerful model capable of orchestrating, communicating, and coordinating large amounts of work between agents, Fable 5.2 becomes a very attractive model. And Anthropic directly points this out in its system card. If we're looking for multi-agency—I always look for that with every system card release. You

[00:03:01] can see it here. Anthropic has been doing this for a long time because they know the power of delegating to agents and the power of small teams of agents. Here they have a team of five agents. This is very relevant to the architecture of the miniature software factory, which we will discuss. But you see here that one agent did the work. It didn't work as well and the task took longer to complete. But if you can organize delegation of subtasks and, more importantly, a small team of agents—it's only five agents— the results come much sooner, faster, and they're much better. And this trend is visible throughout the Fable 5.2 system map. If you are willing to spend tokens and scale the computation to scale the results , you can clearly see that a small team of five agents outperforms not just one agent, but also running a bunch of asynchronous agents. This work has serious implications for your agent design. This is one of the things that caught my attention about Fable 5.2. The other thing is this. In the AI ​​analysis, I

[00:04:01] filtered everything out to show Fable's levels of thinking. It's obviously very expensive, even with the discount they've implemented. It is currently $8 per million incoming tokens and $40 per million outgoing tokens. So again, this is still the most expensive model available. What I really like about this model is that it's not Fable at max. Then again, most of us don't need Fable on max mode. Opus 5.5, Astra, Soul, DeepSeek—these are all pretty good models. What I really like about Fable 5.2 is this . Fable 5.2 medium at a price of $3.80 for the IQ test . Guess where he ranks on the IQ index? He has 56 points. Do you understand? So this is really incredible. What's most impressive isn't the max mode. This is medium mode. This is low mode, right? Look where Fable low is. That's 54 IQ points. Then again, most of us don't need Fable 5.2. I used the Claude 3.1 Pro for some cybersecurity work, as I was limited by all of these models above, and I had no problems. Here are two things

[00:05:01] I really like about the new Fable 5.2 release. These are multi-agent orchestration capabilities, where you use Fable 5.2 as the orchestrator and place other front-end models, worker models, or even lightweight models underneath it. And that's the fact that you don't really need Fable on max mode, or even X High, or even High. You only need an average or even low level, and you will still get a higher intelligence than 70% of all other top models. Models will continue to improve. Fixating on a model is a mistake . As you can see, we have a huge selection of intelligent systems. Now everyone has access to Fable 5.2. The model is not an advantage. It is the system you build around your model that is the advantage. Knowing which model to choose at the right time is key to mastering the four main tools of context, model, and prompts, but it is only one of the four elements. So when the next model comes out , treat it as only a quarter of the story that shapes your agent. To all the Anthropic researchers and engineers watching us: a big hello to you for continuing to push the boundaries, and

[00:06:00] our sincere congratulations on your IPO. You totally deserve it. Now let's shift our focus from the models to the system around them, which gives us a huge advantage, no matter what stage you are at or what intelligence you are using. The system you create is how you specialize and provide unique solutions to your clients. In “tiny software factories,” we will continue to use our feature map to unlock the capabilities of the factory one feature at a time. This is our third of four software factories, and at this third level we have 13 powerful features to work on. Each function has three dimensions: effort, value, and a third dimension—skills. The first and most important property of every tiny software factory is an empty factory. Every factory starts with nothing. Why? So you can customize it for yourself. This is "liquid" software. It is designed so that you can personalize it. It is designed to

[00:07:00] change shape according to your problem. So let's move on to our first feature that you can adapt and extend. These are nothing more than teams of small agents. We have several specialized reliable agents in one factory, each with its own main four components: lists and lines of work. One agent is not enough. If you've worked with agents, you already understand this. Let me show you exactly what I mean and how you can apply it to any problem. So, in the browser, we have a software factory of small teams of agents. On the right we have the usual chat with an agent, and on the left is a list for our lead agent. We'll get to that in a moment. If you press the tilde, you will see that the small agent command selector opens. So we have four agents, each with their own unique pages, each with their own unique list that they work with and focus on. Now we can enter them. So let's move on to our second agent, and you'll see that we've switched to a brand new chat with the agent, new people in the center, and a brand new list on the left. Moreover, each agent has its own set of

[00:08:00] settings, its own unique “core four”: context, model, prompts, and tools. Here are all the tools this specialized agent has. These are, of course, our agents inside the empty factory, so they are just templates. So we can go into the agent and start running some situational queries to understand the system. For example, I will ask: "What is your specialization?" We are now inside our first agent. I don't have a specialization yet. I am number one, a blank slate with no direction, no name, and no mission. What is your topic? K SF read. That's all. It reads its settings. His theme is a factory with a slight variation. And then we can ask something else. What is the theme hotkey? I ask random questions to get started. Perfectly. So, he knows that the hotkey for the topic is H. If we press H, we can of course see it. As detailed in lessons one and two, the "tiny software factory" is designed to be customizable not only to the problem it solves, but also to how you, the engineer, use it. The tools you use directly limit or expand what you think is possible and what you can do. And so our tool, of course, has very, very few limitations. Everything is designed to be customizable. So why is agent specialization so important? This

[00:09:01] means that each agent can be designed to solve a specific problem in the team, down to the tools, prompts, environment, context, and, of course, the model. And we will demonstrate this by moving from an empty factory to a functioning one. I want you to think about what recurring problems you face that you could use a small, dedicated team of agents to solve, because as you know, with each agent you add, your focus becomes blurred. We can solve this with teamlead. We have a single interface for interacting with all our agents. We have a lead agent. This is your orchestrator. This is a single interface. You communicate with this one agent, and your team does the work. What is the specialization of a lead agent? It is designed with one purpose: to manage your team on your behalf by bringing everyone together in one room. The lead agent will launch their specialized toolkit. We have a conversation where each team member responds in one chat. So, all three agents responded. Here you see our personal

[00:10:01] conversation with the lead agent on the right. And then we have a conversation with all the team members in the new agent chat that our main agent created. Let's run another query. We will ask them what tools, model, and topic they have. We see another message from our leader, as well as responses from team members. They all use Workhorse A, as you can see, with a high level of thinking. Here are all the tools and you can see the differences in themes between agents. Our lead agent, our orchestrator agent, of course, responded to us with a concise and clear answer. We can now work through a master agent to scale tasks across multiple agents. In our case, this is the division of work between our specialized agents. So I hope you understand what this is all about. We have a lead agent who helps us distribute the work among many agents. This reduces the cognitive load on agents when scaling and allows them to remain specialized. This is not just situational delegation of subtasks . This is something much more.

[00:11:00] Let's continue to develop this feature with agent chat rooms. This is really powerful. This is an advanced feature. As you can see, it takes a lot of effort to do it right, but the value of it is incredible. So what do agent chat rooms give you? They give you the most important ingredient of a successful team. This is communication. For agents, it's no different than you and me. Good communication is what makes the best teams. Thanks to the conversational contract, our agents can communicate together and create dialogues , each making only the necessary contribution to achieve the result. And, of course, our leader orchestrates and directs the conversations where they need to go. Any add-on is a list of something that is on your list for lead agent tasks. His main goal is team management. So, he's just controlling the conversations. He manages communication. This is the purpose of our lead agent. So let's get started. We will ask everyone to create a minimal client-server-DB architecture for a consumer platform for

[00:12:01] generating images in the form of a page. Abstraction, no special tools , open chat interface, we leave the chat open. My lead agent has received the assignment and is going to delegate this work. If we open the sidebar, we will see that a new conversation has been created. It has become purposeful , and now we can focus on this conversation in our little “ software factory.” You see here that all agents are currently working. We get results from each agent , and they also have a very interesting label. This is a link to an item on their list . So if we click on that, we'll go straight to the main object that our second agent is working with. In this case , again, this is our empty software factory. It's just a page with a generative interface, arbitrary HTML that they can display however they want. So we have a great imaging platform architecture. We have a client API, here is a database and a queue platform for generating images. Then we have an object store, we write back to the database, and that comes back to the interface. Classics, exactly what you would expect from such a program, and we can see which of our participants created the best

[00:13:00] or most interesting version. These are all the same models, so we can expect a similar result. As with the rest of our " factory", if we open the settings , we'll see the main agent settings at the top and a new set of team collaboration. If we move to collaboration, I can put my name, add Dan, and click "save." Now the team will know me that way. I have a unique ID that can be customized, and there is also a conversation. All our open and archived conversations are displayed here. We can, for example, archive our first conversation, and the lead agent will archive that chat, but it will always be available in the conversation settings. Next we have a very important section. We have a conversation prompt that dictates and sets standards for how your team communicates with each other. This is a great opportunity for me to emphasize the importance of your ability to design prompts and create systems that work better than standard solutions. This is a clear example of the fact that the model has

[00:14:00] almost no influence here. After a certain threshold, it's simply coding your desired results using prompt engineering. Of course, from the first lesson to the second, this is a concise extension of the "core four" hints section, where you see the kernel system hint. There is a system hint here of the agent's identity. So, we keep adding rules for the agent over and over again in different domains and environments that have their own unique set of tools they need to work with. That's it. You see the team tools with my name displayed. And this continues. This is a very important, you know, key setting. Here you can see some details. You are a member of a team, the team name is listed here . Prefer short, concise messages. Your nickname is the name of the nickname. And you see here our rules of communication: a message where you are mentioned requires a response, then you act within your area of responsibility. A message that only mentions others—read it and stay away. This is actually very important. We create a social contract for our agents about how they communicate. So if I do something like this: "Leader, who has the best minimalist design right now?" I am

[00:15:00] now addressing the leader. And that's why no one else here will answer. If we open our agent chat, you'll see that we just read all the team documents and it reports. The second participant is highly specialized. So no one else there answered. This is an open chat. They all read the chat conversation. And again , we have a page tag there for quick navigation throughout the experience. I just realized I wrote " Dan" without the "A". Let's fix it and save it. That's all. Agents will only respond when contacted. This is the social contract we create in the conversation prompt. But each agent will still read the conversation to know what is happening. We can see it. We don't need to guess. You don't have to take my word for it. We can just take a look. You can see here, in the conversation for our agent "participant one". This is addressed to the leader, not to me. So I keep quiet and don't send anything. You see him saying that. Of course, as you can see here, we have a tool summary from lesson two summarizing each tool call so that we can again reduce the cognitive load and focus on what's most important—the actual work, not reading tool logs. We see this with our agent "participant two." Same

[00:16:01] situation. Here is his page. The engineer turned to the leader, so I remained silent. And with "participant three"—the same thing. This is indeed a very, very powerful mechanism. We created a social contract for our agents working in a small team so that they interact well. This is just one chat. We can do much more like this. I'll say create a chat with a sixth participant, ask them to add more details to the architecture, and start defining the exact toolkit we'll use. And here in parentheses I will add: only proven open source technologies on their page. Let them think about how the agency team can specialize within this project. So, I run this, and a chat room for agents is created. This is just the second participant and the ice. We can go here by clicking on it. You may see a prompt. We can observe to measure and improve. It is very important to have visibility of processes. You don't want a bunch of random autonomous units running around your business, wreaking havoc, and you can't track it. By the way, about tracking: we still have our tracking system, which you see here. We have a

[00:17:01] state-of-the-art S Plus model and we have all the records for every execution run to observe, measure and improve the system. Agent Two really works. If we go to its interface, it refreshes the page. So we'll just give it a little more time to update. You can see he spent time thinking about how to improve. A nice block of thoughts. And now it's going to be updated, and we can look here to see, you know, what stage it's at now. Here it is. You see how it generates. Very, very cool. A bunch of HTML code that neither you nor I need to waste any more time on because we've moved up the stack. Here comes the page refresh command. Here is a summary of the tools for the page. Advanced tool architecture. Perfectly. Now we can see what it looks like. You see they responded to the lead, but we need to focus here. Good customer. They want React. Er, I should have said Vue. Fast API. Okay, it looks good. Postgres looks good. Rabbit MQ. Okay, we accept that . The generator is here. Object storage. And so on. So we got more details added as requests. We have our endpoints. Here is the API service. A little

[00:18:00] more documentation for this. So, it looks good. We use multi-agent teams in this empty factory to plan future work. Let's go back to the main agent , and you'll see something very powerful here. My agent has decisions that I have to make. So I'll put that question aside for now. Before we move on to the “man in the loop” controls, we should discuss another extremely important feature. I'll just close these windows and we'll come back to them later. Let's talk about why this is also powerful. Thanks to the main agent, agent chats, and specialized agents, we have control over the process. Again, our master agent reduces cognitive load, so we can do more with specialized agents in less time and with high efficiency. The lead agent configures the participants' parameters, and can intervene, direct, and adapt the work. The key point is that our main agent doesn't actually do the work itself, because what does it consist of? His job is, in fact, team management, real management and coordination of actions. By the way, you can also see a persistent cron job running cyclically. The lead

[00:19:01] agent checks the status every minute to make sure nothing is missed in the work of the small team of agents. Again , this is the material of the first lessons. But now I'll write this request directly into the conversation , go to our general chat, and say this . I'll say, "Head agent, organize a three-round discussion on the optimal factory settings that each agent needs to create an image generation platform." I'm launching this, and now the lead agent will start a three-round discussion. It's really powerful, we can open a window and see how the main agent thinks and goes through all the stages. Your lead agent helps organize communication between agents who directly perform tasks. Okay, here's the message. We'll have three rounds of debate, okay? Let's just pin this down below. This very quickly went far beyond the standard capabilities of agents. Here, agents communicate with each other over several rounds, speaking when called upon, while respecting appropriate communication boundaries. Each agent provides their feedback on how we organize the factory, their specific

[00:20:00] settings for creating this image generation application. You see all the chat messages here: round two, participant three. Here is the main agent starting the second round, and here is the final round. Each provides one message. This is what they will apply , so let it be complete and accurate. Settle this first. Each agent will respond with their own requests for changes. By the way, at the bottom of this request, if we go up here, I said that after the discussion is over, you need to collect feedback, and then you can directly make the requested factory configuration settings that each agent wants. And this is our main agent who has full control over the factory. Anything you can do, anything you would do, your main agent can do on your behalf. This brings us to a very important idea that we have emphasized lesson after lesson: parity of agential access. There is still some discussion going on here . Each of you chose X high, now look at this. The agent forces each agent to update its own plant configuration. If we answer in one line, what exactly did you apply and if everything else seems unsuccessful or wrong. Each agent is fully customized. If we

[00:21:01] now go into a factory where a moment ago none of these configurations existed. Let's move on to the configuration. Now we have the API keeper, and you can see that the agent has configured itself. Let's open the general view. So, we have a model, a context, a compactness. And we can, of course, press M to go to the model. We see that we are at X high in workhorse. Looks great. We can move on to the next agent. This is our pipeline forge. We see that it has a task configuration and a navigation bar . It has a context window, workhorse A. You can press M. We see that it is at X high, and so on. Here is our client QA agent. My agent self-organized to this configuration. He's still at an average level, so he decided he didn't need any more intelligence. He actually lowered the level to workhorse B. Very interesting. Context, he set himself 200 thousand, request, tools and so on. We just got our agents to tune in on their own because our lead agent has lead control and can have orderly conversations. He can communicate. And this is the main advantage that your tiny software factory has . This

[00:22:01] third-level factory really brings together all the features we've explored. We specialize and then quickly manage them through a single interface, which is the master agent. A conversation between all participants is available for confirmation. Let's talk about an important feature that underlies why the tiny software factory exists at all . This is, of course, the concept of a person next to a cycle. So, with Cron, timers, triggers, and a small team of agents, your factory can run without you, as you will see in the example of a working factory. But to do this, you will need an approval, feedback, and rejection mechanism. This is a requirement for moving to a near-cyclic system, because if you're stuck in a cycle, you control everything. You are a necessary component of the system. And that's a big advantage that we were looking for, an advantage that opens up when you have a near -cycle system like a tiny software factory. Here's what we'll do. Let's go back to our system. I will speak directly with the lead

[00:23:01] agent again, gather inquiries from the second participant, and present the decisions we need to make regarding the architecture. I used to kind of bypass all these decisions that needed to be made, and now we're going to look at them. So, the main agent will start working and will contact our conveyor forge, our second specialized agent. Here you see him thinking and preparing the decisions that need to be made for this architecture . It looks like he's going to create a page for us. And, you know, all this time we can, if we want, switch to our specialized agent or just stay at the top level with our main agent and wait for a response, for a result. So, thanks to the architecture of a tiny software factory, everything is assembled here for you. We can always see exactly what our lead agent asked about, and I want to expand the tool summary here to show a few lines and see more details . Here it is. The lead agent reads the result. Re-presentation of solutions . I will accept them now. My agent is being smart because I turned them down. He thinks I don't want to receive them. I'll just have him reintroduce them

[00:24:00] here, as if we're going through that natural flow when they were introduced originally. That's all. Team request. And if we open the chat, you'll see that there are architectural decisions that need to be made now. If I click here, I can accept them all. You see he's lining up a bunch of requests for me from the team. That's it. And now I can just take turns. Again , everything I've done up to this point is just my manipulations inside the loop, right? I was setting up a factory. It's time to appear in the cycle. You build a system that builds a system. But at a certain point, that's exactly what you'll want. You will want your agents to work for you, and you will see this in the current system. This will be quite clear to you , but here you see what our agent is asking us. This is a simple questionnaire interface. You've probably seen these on your system that runs 24/7. This becomes very important and compelling, because imagine: you are somewhere far away, working on another system, creating products for the company, and here you receive an SMS or a message in Slack. Whatever your system reports, your specialized mini-development team writes it for you, and you sit down, review, and answer the right questions. So

[00:25:00] let's do it now to unlock their work. Image model—choose self-hosting , Docker, Kubernetes. I don't like either of these options. We choose "raw". Many engineers will not like this decision, but it is our choice. We will use Postgres as a queue. Postgres can do it all. Fast API is quite suitable here. We will host the object store ourselves instead of a managed service. We will host everything ourselves. Where to check content, queries and results ? Now let's see. Oh, I see. This is where we conduct a content moderation check. Does this apply to queries and results? Keep until the user decides otherwise. This is appropriate. Let's start with these threshold values. Yes, that's good. You see all my decisions being re- entered into the system. Everything works in natural language, using special tools to solve a specific problem. You can see that there's no reason—and this is an important concept for a working system—to have a bunch of other tools. Specifically, does my lead agent need coding tools? No, he does n't need them. It has user settings from the second lesson. This is important . Does he need specialized subagents? Most likely, no. Enduring tasks are good. The classifier model

[00:26:00] can probably be turned off. These are all settings that we can change at any time. So, we can edit them right now. System control is good, team control is good. We can disable subagents and so on . You have full control over the system. When your agents reach out to you, it’s a key feature that moves you from participating in the process to observing alongside it. And again, you'll see this in a more direct, practical way when we launch the software factory . The value of your tiny software factory and small team of agents is when you take an empty factory and give it a specific goal, a mission , a class of tasks that need to be solved as a team around the clock, with you by its side in the loop, not at the beginning. This brings us to the crucial moment when your empty factory becomes