EPISODE 1982 [INTRODUCTION] [0:00:00] ANNOUNCER: AI coding agents have made individual developers dramatically more productive, yet most organizations aren't seeing anything close to that gain at the company level. A key reason is that shipping a feature to production involves far more than writing code. Triage, review, context, guardrails, and human approvals all surround the work, and agents add new risk by acting in ways teams can't always see or control. Turning individual gains into real organizational throughput has become one of the central challenges of the agentic era. Port is an AI software factory platform that lets platform engineers build, operate, and govern an AI software factory, which is a layer that sits above the coding agents. The factory is a model and agent agnostic while supplying a context lake that encodes an organization's taxonomy and data, governance, and guardrails across each stage of the software lifecycle, human-in-the-loop checkpoints, orchestration across different agents, and a registry of approved agents and skills. Yonatan Boguslavski is the CTO and a co-founder at Port. In this episode, he joins Kevin Ball to talk about the shift from writing features to factory engineering, how a context lake structures organizational knowledge so agents can actually use it, how governance works across an agentic software lifecycle, and the build versus buy question of where a platform like Port fits. Kevin Ball, or KBall, is the Vice President of Engineering at Mento and an independent coach for engineers and engineering leaders. He co-founded and served as CTO for two companies, founded the San Diego JavaScript Meetup, and organizes the AI in Action discussion group through Latent Space. Check out the show notes to follow KBall on Twitter or LinkedIn, or visit his website, kball.llc. [INTERVIEW] [0:02:06] KB: Yonatan, welcome to the show. [0:02:08] YB: Hi. Thank you for having me. [0:02:10] KB: Absolutely. Well, let's get started with a little bit of your background. So can you share a little bit of your career to date and what brought you to Port? [0:02:19] YB: Yeah, sure. So I worked for many years in the intelligence unit in Israel, and I worked in the platform department. And we had a simple but difficult problem to give services for thousands of developers in this unit. And we always should find the trade-off between giving them the opportunity to run fast, but also we as the platform info team to make sure that we keep our standards, that they don't do misconfiguration, and always you need to find this balance. And it was super fun. And then with Zohar, my business partner and the CEO, we decided that, okay, the problem that we solve for so many developers in the intelligence unit, it's basically the same problems for also other companies. And we thought how we give the best tools for the platform engineers to build the platform that they expose to developers so they can run freely, but still the platform team and the infra teams will be able to sleep well at night. And now with agents, the problem is 100 times bigger. So it's even more challenging, but also more fun. [0:03:21] KB: Yeah, that makes sense. So let's maybe talk through what that evolution has looked like. What was Port originally? And then how has it evolved for our new agentic era? [0:03:30] KB: Yeah. So I will start with the most simple example. A developer wants a database or an S3 bucket, but we can't just give him access to AWS. There are so many params, so many things that he can just do mistakes. We want to create some abstraction for the developer that he will choose just the params that he needs. And of course, we can give also different options for different personas in the organization. So maybe the front-end developer will see three params, but the back-end developer will see 10. And also, in each company, you have abstraction for each persona, but also for each company, you have their own abstraction. And the developer just fill in the relevant properties and behind the scenes. You can create like a flow that's opening a pull request with Terraform code. And behind the scenes, you do the things in the right way. And eventually, the developer will get all the information that he needs and also ways to operate in this. Not only the creation, but also the second day, and he will be able also to add resources, change resources, and so on. And it's one example of creating database, but it's for everything, for creating repo, for changing secret, for adding feature flag. So this is one part, the self-service and also the context. So we wanted to create a context for developers. So as a developer, I log in, I see a service catalog of all the services in the organization. And I have the context. I can do a right click on a service. And then it would ask me, "Okay, you want to add S3 bucket to the service? Why?" And it will open the pull request in the right place. [0:04:57] KB: Got it. So if I'm understanding correctly, you're essentially providing for companies their ability to run internal versions of a Heroku or Vercel style thing where it's infrastructure as a service kind of constrained enough that you're able to very predictably generate the appropriate Terraform code. [0:05:14] YB: Yeah, and it's not only Terraform. We basically sit on top on all the tech stack of the company. So if you work with Terraform, Jenkins, GitHub, Azure, AWS, we have absorption on top of it. [0:05:24] KB: Got it. [0:05:24] YB: So you choose the way you work and we just give you the platform team the way to abstract it to the different personas. It can be the security teams, the developers. [0:05:34] KB: Okay, awesome. So now, as you highlight with agents, there's a whole new world here. What has evolved within Port for that? [0:05:43] YB: Yeah. So the first step, it was that, okay, now I want to ask those things also from using MCP, from my ID, from Cursor, from Claude Code. And I want to run also agents that not run on my local machine also need those resources. And you need to start to build the organizational language. Also, the agents need this organizational language. So we talked about the service catalog. But what does it mean service? In every company, service means something differently. What is environment? What is workload? So you need to create this organizational language. We call it context lake. Also, the same way you need for developers, the same thing for agents. First of all, when they understand that they need to roll back a service, an agent, for example, if you try to create some self-healing incident agent, you want that, for example, the rollback tool that you give to the agent will run a specific GitHub workflow. A specific GitHub workflow that the platform engineers decided that this is the best way to do a rollback. And you want to do a rollback to a specific service. So you import, you define what is service, what operations the agents can do on the service. And behind the scenes, when the agent decides to do a rollback operation, how to make sure that it triggers this specific GitHub workflow or do this specific pull request or specific CLI command. [0:06:58] KB: Yeah, okay. So there's a lot of different pieces in there to unpack. Let's start with the context lake, because I think this is something that, from my observation, a whole bunch of people are trying to solve this right now and figure out, "Okay, how do I create this? How do I keep it up to date and maintain it as things change? How do I expose it appropriately to agents at the right time?" So what does that look like for you? [0:07:21] YB: Creating the context lake, it's a couple of stages. The first stage, as I mentioned, first of all, you need to create the taxonomy of how everything works. As I said, what is service? What environment? What is deployment? What is workload? Workload is algo application. It's Lambda. It's neural service that you need to define what it means in your organization. You define, first of all, the organizational language. [0:07:46] KB: And how structured is that definition? Is that mapping to deterministic primitives that you have? Or is that like freeform text for an agent or something like that to interpret? [0:07:55] YB: It's like designing ERD in database. You need to configure - before you ingesting data, you, first of all, just decide about the objects that you have and the relationship between them. You say every service can be deployed on couple of environments. So you create a service deployment environment, you create many relations between them, you really define - [0:08:17] KB: You are kind of building that structured definition. That's fantastic. [0:08:20] YB: Yeah. [0:08:21] KB: Okay. Cool. [0:08:21] YB: You built it by yourself. Of course, we have AI to help you to build it, but you need to define it. And then you start to ingest information from the different systems. We are mainly want to be the engineering context lake. So you connect to GitHub, Datadog, Kubernetes, AWS, and you start to map the data to the objects that you created. Again, I will take the example of service, if you want to map services. If you work in monorepo, so you are going to map folders to service. But if it's not monorepo, you are going to map repo to a service. We give you all the easy ways to configure the data to your language. Then you also start to connect between the different tools. You bring - let's take the ownership part. So you bring Jira users, PagerDuty owners, the code owners file. And now you want to create a map to understand like, "Okay, this service, who is the owning team? On this service, who is the on-call? And which PagerDuty service related to this repository?" So a lot of connection that you want to create in order to give a good context to the agent. We give you deterministic rules that you can use them to configure by different labels, different tags. But we also have auto relation agent that come with suggestion and say, "Okay, I think those are the owners of the service. I think this service depends on those service because we took data from Datadog and there is some dependency between them. And we also read the API definition. So we think there is dependencies between the services." We give a lot of suggestion on how you can enrich the context lake. Then, once you have the data, agent can start to query it using MCP. You automatically get an MCP and you can also create a logical MCP. What does it mean, logical MCP? We don't always want to give all the data to the agent of the context. You can create logical MCP for different use cases. So for example, for this team, while there is incident, we'll get this specific MCP server with not all the data and you can configure the name of the tool so it will be also easy for the agents to pick the right tools. This is the main context lake. Of course, we can talk also about how to connect MCP connectors and why MCP is still important. [0:10:30] KB: We'll get there. So a couple of different things on this. Love it. For keeping things up to date. So once you've done your wiring, are you observing changes as they happen? How is that happening? [0:10:42] YB: Yeah, so we first of all do like a full resync. We bring all the data and then we have - listening to a change in real time. So with some pod, you kill the pod in your Kubernetes, you will see it in the platform. There is a new pull request, you will see it immediately in the context lake. [0:10:55] KB: Got it. Okay, that makes sense. Question I had related to taxonomy. So every organization that I've ever worked at, there is the aspirational taxonomy. How we want everything to be defined. And then there's the tech debt pieces that don't actually fit that taxonomy yet because this service is actually split across these five places, or this isn't really well factored, or what have you. How do you deal with exceptions to the taxonomy? [0:11:20] YB: Because sport is so flexible, we also give you a way to handle it. So you can create - maybe in your taxonomy, it's not perfect, but maybe a blueprint for monorepo and a blueprint for not a monorepo. It's not perfect, but you can do it as a middle step to the end goal. We also have a concept of scorecard and initiatives. For example, sometimes you can't map everything perfectly because you don't have tags on your cloud resources. And in order to map it, you need that all the cloud resources will have the relevant tags. So you can create campaign and initiatives as a platform engineer in the company and start to send different nudges on Slack, on Teams, to the different teams to put the relevant tags. And then it's like we give you a way to encourage the teams to work in a more accurate or with the standards of the organization. [0:12:06] KB: Yeah, nice. Okay, I am curious to get into this MCP piece. So there's a couple different things you highlighted there that I want to dig in. One, you mentioned, we can talk about connectors and MCP and how to do that. Before we do that, I'm actually curious to dig a little bit more into the logical MCPs. Now, are these - from the perspective of an agent, these are new MCPs that I'm adding up? Or this is a configuration and it changes the configuration of a single server I've already linked? Or what does that actually end up looking like from an implementation standpoint? [0:12:36] YB: Yeah. You, again, as a platform engineer, we give tools to the platform engineer. You can create in Port a couple of MCP servers. Really for the agent, it will look like a completely separate MCP server. And then you can create an MCP server. Let's call it an incident manager MCP server. This is the MCP server that you just need for incident. And then you can configure the name of the tools. Instead of using Port's API or things like that, we have a concept, we call it blueprint identities, but we don't want that the agent in the company - necessarily, he shouldn't know what is blueprint identities. He just wants one tool called get current incidents. So you can really configure the names and the params and what data you can access in a really easy way. And then you configure for the right use case and persona. You can create a couple of MCP servers. And then when you create the whole agent in Claude Managed Agent, in Cursor, you can just configure the right one. [0:13:28] KB: Got it. And is that something - I'm trying to think about the life cycle of this. Is this something where you're creating these durable things based on recurring issues that show up? Or are these lightweight enough that I might do one-off MCPs for this particular situation I'm dealing with now? [0:13:44] YB: Yeah. So it's more for things that like happening in a recurring manner. For example, of course it can be helpful for - for example, I'm a developer and I'm working for my Cursor and I'm from the front-end infra team. So I want my perfect MCP that knows how to handle with Figma and so on. This is one use case. But the more interesting use case that I want to create something that runs on every incident, on every PR, on every GR issue. In the end of the day, it's the same query most of the time. And I want to make it perfect for specific use cases. [0:14:17] KB: Yeah, that makes sense. Another thing that leads me to is iterative improvement, right? If you create one of these, say you have an incident MCP and I'm a platform engineer and I'm managing, I'm managing that MCP. That's my ownership. What tools do I have from Port to see is it working well? How might I change it? How is it being queried? Those types of things. [0:14:37] YB: Yes. So we give you analytics on the MCP tools that you use in Port. It's still not easy to always to improve only the MCP. Eventually, you need to improve a lot of stuff to improve your incident process. [0:14:51] KB: Yeah. It probably is downstream a few steps. Yeah. [0:14:53] YB: But yeah, we give you analytics of which agent uses which tools, if it was successful, if it was not successful. We come with suggestion, but you can also use the data to make decisions by yourself. [0:15:04] KB: Got it. Stepping back out one level of abstraction, we're down in the details of what the platform does. I think one of the things that I saw as we were preparing for this is that you all are really trying to support this full agentic software development lifecycle and this concept of building a software factory that everybody's trying to figure out. How are you thinking about that? What are the different pieces that go into that? And how does Port fit in? [0:15:30] YB: So we see that there is a lot of 10x developers. It's really like all the engineers can now do really 10 times more work. But we see that organizations as an org, the org is not becoming 10x, maybe 1.2. And we try to understand why. And there is a lot of steps of taking for fixing incidents, for taking features to production, for taking bugs to production. I'm not familiar with companies that taking features and it's go all the way to production without human intervention. This is the dream. And I think now the coding agents are good enough to start to go to this mechanism that some of the features will be improved without human intervention. But we need to create a robust system to make it in a gathered way, especially in enterprise companies. And then in Port, we build the platform on top of the agents. And what is the agent? There is, of course, the model. There is the harness. Now we see all the companies also releasing cloud agents. So Claude with cloud manager agent, Cursor with cloud agents, Codex, of course. They're releasing also the environments that are running the environments. We sit as a layer on top of those agents, and we are model, agent, harness agnostic. And we give platform engineers to build the process that will help to take, for example, the feature, but it can be any agentic workflow to production in a governed way. And we can talk like pillar by pillar, but the main pillars in this minfra is the context that we spoke about, governance, what should happen. For example, the agent can deploy, but he must follow those scorecards. And if he wants to deploy, he must use this specific GitHub workflow to deploy. There is human in the loop. We know how to bring human to approve, decline, or continue the agent session. Maybe the agent did a good job, but not perfect. It did like 90% of the job. And now I want to take it back to my local machine and then bring it back to the platform. We give all this experience. We give the orchestration layer, so you can run from Port. We have integration with all those cloud agents that you can trigger. You can say for the triage process, I want to use Claude. For the coding, I want to use Cursor. And for the review, I want to use Codex. So you can easily orchestrate it in port. Then we give also metrics to understand if it's working. Metrics is kind of how many PR merged in this factory line, how much it costs, how many comments on each PR. We store the agent session so you can then also to learn from it and improve the factory and make the factory line more smarter on every ticket. This is the pillars that we provide. And also, an important part that we provide is also the AI registry. We provide you - we have integration with all the agent platforms. In Port, you can manage a certified list of all the agents in your engineering, all the skills, all the plugins. And they're also part of the context link. You can also say, okay, you can - for example, we say developers can create a database. Now they want to create agents, but you want, for example, say you can create agents, but only with those certified skills. This is also a flow that we simple. [0:18:34] KB: Interesting. Okay. Well, let's start diving in a little bit more detail on some of these pillars. And I'm going to start with one that is unsexy, but everybody seems to be struggling with it, which is governance, right? I feel maybe it's died down a little bit, but for a while there, it was every week somebody was like, "Oh, my agent deleted my database or my agent did this that I wasn't expecting." And I think we're still seeing examples coming out of OpenAI and Anthropic where agents are going off and doing things that they don't have any visibility into, or if they do, they're not telling us because they act surprised when they say, "Hey, this posted this in this public location." What does governance look like within Port? [0:19:11] YB: Yeah. So we focus on governance on the SDLC. By design, the SDLC is kind of every company is different, but you have kind of the structured process. You have a triage, coding, review. Of course, it can be 10 stages and always can be a little bit different for bugs. Features for different teams get different processes, but teams have some structure already in place. It's difficult to make sure in deterministic way that the agents apply those rules, but you have some structure. The way we implement the governance, first of all, you can create a couple of factory lines. So you can create factory line for - each team can create their own factory line. You can configure one factory line for those type of bugs, for front-end bugs, another factory line for more docs issues. Then you define the stages. Let's take the example of a feature. So let's take a simple example. It will be, I want to triage, to assign the relevant service and the owner. Then I want to open a pull request. Then I want to assess the blast radius to even understand if I can deploy it automatically. Then I want to run the QA agent and the review agent. And then I open a PR. Let's keep it simple. Of course, then I can add more agents of like also to babysit it in production and make sure it's working. But you define the stages. For each stage, you define which will be the agent that will execute it. And it can be one or more agents. Every agent is connected to Port MCP. So you can say like which. And because in Port, you can manage all your skills catalog, tools catalog, so you can pass to the agent with which skills and which tools it can operate. You still can write any code that you want, for example, but if you want to do things that are more close to the infrastructure, we need to use Port's tools. Then you also define what is the output that it needs to produce, kind of a checkpoint. You can do whatever you want, but eventually you need to provide JSON with, for example, the severity, the owner. In order to pass to the next step, he must provide this information. You can decide on each step if there is any for human approval. And it can be like one human, couple of humans. It can be a chain if the team leader approved. Now go to the department leader and also approval for him. We focus a lot on this. You define those different governance, different steps and rules that the agent must apply. You can configure scorecards on each stage. You can say, okay, you can deploy, but only if it's in the working hours and there is zero incidents right now. So we can create a lot of deterministic rules. Yeah, and this is basically how we give you a lot of ways to put gadgets in different stages of the SDLC. [0:21:57] KB: Got it. That makes sense. [0:21:58] YB: So we move for the outer loop of the agents. [0:22:00] KB: And are you owning the execution environment for those agents? It's running in your own sandbox or something like that, where you can maintain what are they allowed to touch and not touch? Or how is the execution piece of that workflow happening? [0:22:15] YB: We trigger the tools like Claude Managed Agent or a Cursor cloud agent. They are responsible on the environment. We also have a Port agent, if you want to use it, for more simple stuff, like triaging or assigning owners. And then we run it, and this is our agents. And of course, we have customers that run the agents on their Jenkins or their GitHub workflow, and they run Claude Code CLI on the GitHub workflow, and it's also a way to trigger it. But we give the responsibility for the environment to the user. [0:22:47] KB: Got it. Okay. And so in terms of then those guardrails and pieces, are you kind of mapping those down to configuration in those different environments or that's happening completely outside? You run, you get a handoff, and now Port is checking a thing. [0:23:04] YB: You configure everything in - by the way, you configure everything in Port as code. So you define everything in Port, but the execution itself, we send the request to, for example, to Claude Managed Agents. And we know to monitor it, see the logs. They're in Port, we have a live status, but they are responsible on the - [0:23:20] KB: Okay, cool. Yeah, that's a nice division of responsibility. Let's dig in a little bit about monitoring as our next pillar. What are the different pieces that you're monitoring inside of that factory line? And how do those end up getting exposed in port? And what could we do with them? [0:23:36] YB: So one of the most important thing in factory lines is to create this closed loop, that eventually we want to get to a situation that from every ticket, from every incident, the factory is becoming smarter. So we store everything that passed through those lines. Of course, the PRs that were created and all their comments, all the JIRA issues that went through the and the comments there, the agent sessions, the traces, the skills that were used. And then, first of all, we store it and create an easy way to access it. Then we come with out-of-the-box agents, but you can also bring your own agents to analyze the data. And then you can run it on an hourly basis, on a daily basis, and come with suggestions, and now we can change the skill to improve the efficiency of the factory. Or maybe the efficiency is great, but instead of use Opus, we can use Haiku and it will be the same result. Based on the data, we always come with a suggestion that you can apply it, apply the suggestion. And we monitor eventually the higher-level metrics of how many features were deployed, how many PRs were merged. And then you can see if the changes in the skill, in the context lake approved. For example, we see that a lot of features in the factory line are causing incidents. It's not surprising. But maybe we can make sure that the blast radius agent does a better work. We understand that maybe we can add dependencies to the context lake and integrate another tool. And then once we have dependencies, maybe we can be more cautious before we deploy. [0:25:15] KB: Yeah. I like that a lot. And the metrics and having the metrics integrated really helps with a challenge I feel like a lot of folks run into, which is how do you do full agent level evals? We've gotten reasonably good at, okay, I can eval a particular step, but evaluating the output of - in this case, it's a chain of agents doing different things is hard. And having those end metrics really helps with that. Let's go back to another thing that you mentioned, which is in terms of managing the sets of agents that are available. I'm definitely seeing in my organization, there's a proliferation of agents. Everybody wants their own. We're building this, we're building that. And it's not governance in the same way, but managing what are all those different things? What are they doing? Is there already something that does what I need? It's hard. You mentioned that you have a registry or something like that going on in Port. What does that look like? [0:26:05] YB: In the beginning of the episode, we talked about service catalog. So you want to see all the service in the company and you want a gathered way to create service and see that the service is in the standards of the company. Agents is basically the same thing. But again, one other time is a bigger problem because if a service you create once a month, once a week, agents, everyone creating a couple of times a day. The way it works, first of all, we have integration with all those different platforms with Bedrock, Azure, Foundry, Claude, Cursor. You install the integration and you see like the list of all the agents. Or if it's local agents, we can also read your GitHub. And from the Agents.md and all the configuration that you store there, we also analyze what agents do you have. Then you can set up a different scorecard. You want to make sure that every service is an owner, every service has description. It uses models that you want and not like any model. So you define those scorecards. And then you also define a golden path to create agents. Again, the same thing with the database, some things you want to give the developers to choose and some things will be chosen by the platform team. You create this golden path and then like new agents are being created in the standard way with the skills that are certified by you, which also have a skill registry with the MCP that is certified by you. And then you can also - so you can create in the right way. And then using our Port scorecard, you can make sure the agents are created in the right way and still are keeping the standards of the company. [0:27:39] KB: Awesome. I'm going to step back a little bit now and ask about who are the folks, what size engineering org does it make sense to start bringing something like Port involved? I've worked in a very small environment. We're still single digit to maybe 10-ish engineers working on a thing. I don't have a dedicated platform team. Is Port going to be helpful to me or is this like more - once you've got a dedicated platform team, you're really trying to standardize all your different infra? Where do you fit in that kind of tech company evolution? [0:28:10] YB: So the more complexity you have, you need Port because you have more guidance that you need to put, more standards that you need to apply. But we see also a lot of small companies starting to use Port because they want to build things in the right way from the beginning. Because if you start without standards and everyone can create their own agent without any government, then it's possible, but it's very difficult to keep the company work in the right way. And in Port, we give you some golden path, not only to create an agent, but some golden path how to build your SDLC in the right way. Of course, it's changing every week, but still you always know if you have big diff between the different teams, if there's some standards, consistency. We see also small companies want to do it in the right way from the start. [0:28:56] KB: Tell me more about how you fit into this competitive landscape and this new category of an AI software factory. [0:29:04] YB: Yeah, so we see that there is - to create a full SDLC of taking feature to production is a complex process. I described pretty naively in the beginning that there is a triage opening a PR to review it, but there is a lot of things that should happen in this simple process, a lot of guardrails, a lot of contexts that you need to bring to the agents. You need also some agents that learn from the different data that's happening in the factory and improve the factory. Sometimes, you want to create with no deterministic stuff. For example, you have a long list of PRs that are stuck and you want to nudge the relevant developers. Maybe there is something in PR and you get new info from the PM and you want to bring it back to the triage process. A lot of things happening and a lot of things that you need to handle in this process. Port provides a platform for the platform engineers to manage it. And we see that it's a different category from doing the work itself. We are sitting above even the cloud agents and give the platform team the option to create a software factory with context, governance, self-improvement factory. We see that the companies - every company wants it, but coding agent companies like Devin, for example, or Cursor, they're focusing like how to build the best start as the best agent, but there is a lot of M layer on top of it that you want to make sure not only the developer itself becoming like 10x better, but they all become 10x better. And this is where Port comes in. [0:30:37] KB: Yeah. That kind of points to this interesting question around like what is the role of an engineer in this new world? What is happening with software engineers in the world that Port is enabling? [0:30:51] YB: It's a big transition. Still, developers are writing the code. And the complex part of the code, they are still going to be responsible on creating the new design architecture, the complex feature. They will take part of the product walk. But there's also like a new term now, factory engineering. How the developers - again, they don't build the feature itself. They're building the factory line to make sure the agents can deliver the feature in the best way. They write the skills, they provide the context, they're writing evals. Eventually, we want from every feature that produces an incident to create from this feature and incident to create an eval. For the next time, the agent will know how to operate better. So instead of software engineering, it will be factory engineering. And I think it will be very similar to coding, but just like you will focus on how to improve the factory and not writing the features itself. [0:31:48] KB: And I feel like some people are investing in the factories and they're saying, "Hey, this is a competitive advantage for us. We're going to be better at this than everyone else." Obviously, you're saying, "Hey, this is its own specialty. You should outsource how all the pieces work to us." What does the build versus buy look like here? And what is the case for like, "Hey, this is infrastructure that we should have Port do for us?" [0:32:12] YB: Yeah. We see Port as a builder tool. Port is a platform for build, operate, and govern your software factory. So you build using Port. We really believe that in every company, every company is a snowflake. There is their own processes, how much they want to give to autonomy for agents, how much guardrails they want to put, they deploy every minute or they deploy once a week. Really, every company works in a different way. And we want to give the best tools for the different dev teams, for the different platform teams, eventually to create a factory that fits their specific needs. I don't think that you can buy just a software factory, a software factory product out of the shelf that you just bring your Jira backlog and that's it to your company. You need to build it. And we see you build with Port, the same kind of you build with Lovable website. You build with Port the factory lines. A lot of things you want to own, like writing the skills themselves, writing the evals, deciding about the taxonomy of your organization. So you want to build it. But you don't want to manage like all the RBAC to decide which tools each agent can access, which data, how to trigger the different agents and to monitor them. So a lot of things you can use with tool like Port, but still a lot of part of your factory, you need to build it yourself and Port can help with a lot of parts, but still you need to own it. [0:33:41] KB: Yeah, that makes a lot of sense. I think the one other sort of question I have is what's next? Where is this going? It's hard to project in our current AI world. It feels like things are really moving very, very quickly. But what's on the horizon for Port? What are you tackling next? And where do you see this going? [0:34:01] YB: We really believe that you can get to - it's very difficult, but you can to get to a situation that you have like zero bugs, zero vulnerabilities, even with the fact that agents just writing more and more code. But you can get to a situation like this, but you need to build the right process and the right guidelines and the right context. And we want to work to more and more companies to get to it. What we see next? Eventually, there is a lot of - still, it's not a DAG factory. It's not like just you put the agents and they do all the work and the human. We don't need them. There is still a lot of interaction between a human and agents, like providing more context, changing the skill and so on. And we want to create like more proactive agents inside the factory. I will give an example. A support engineer opened the ticket to the factory, but the ticket was not perfect. A lot of info is missing. So we wanted the factory, we'll speak with the support engineer in Slack and ask him the relevant questions. And then we led it to the factory. And then maybe after the coding, we even realized that, okay, we have some misalignment with two different product teams because their spec contradicts a little bit. So maybe we want to add both those product managers the factory and try to get, again, the relevant context for the coding agent to make the right decisions. Are we to make it more to handle those not ebb and flow situation in a more human way? And this we also see part of the factory's job to make sure we get all the relevant context from the humans and give them all the relevant context. [0:35:29] KB: Awesome. Well, we're getting to the end of our time here. Is there anything that we haven't talked about that you think we should discuss before we wrap? [0:35:36] YB: I don't think so. It's really exciting times. Every week, there is something new. And we see the platform teams, the AI excellence teams, they are responsible of bringing the AI to SDLC. And it's really fascinating to work with those teams and to add AI to the SDLC. And just to see like the org becomes 10x more efficient, 10x more organized, 10x more secured, it's exciting times. And again, thank you for having me. [END]