1. Podcasts
  2. Software Engineering Daily
  3. The Rise of the Software Factories
Software Engineering Daily

19 Nov 2026 · 36m · 21 chapters

Episode artwork

The Rise of the Software Factories

In short

Why individual AI coding agents don’t automatically translate into company-wide throughput, and how “software factory” engineering adds context, governance, orchestration, and feedback loops. Port is presented as a platform layer above coding agents to build, operate, and govern agentic SDLC pipelines.

Guests and backgrounds

Jonatan Boguslavsky, CTO and co-founder of Port; previously worked in Israel’s intelligence unit platform department supporting thousands of developers while balancing speed with standards. Kevin Ball, VP Engineering at Mento; independent engineer/leadership coach; co-founded two companies (served as CTO); founded San Diego JavaScript Meetup; organizes “AI in Action” via Latent Space.

Key claims

Factory engineering is needed because shipping to production requires triage, review, context, guardrails, and human approvals; agents add risks teams can’t fully see. Port is model/agent/harness agnostic and uses a “context lake” plus governance and orchestration.

Notable examples

Abstracting AWS access (e.g., database/S3 creation) into persona-specific, Terraform-backed flows; defining a rollback operation that triggers a specific GitHub workflow; incident/PR/issue “logical MCP” servers; governance stages (triage → PR → blast radius → QA/review → deploy) with JSON checkpoints and scorecards; analytics that track PR merges, incidents, and agent tool success to improve the factory.

Written by AI. May contain mistakes.

Chapters

0:00

The AI Coding Agent Productivity Paradox

Explore why organizations aren't benefiting from AI coding agents as expected.

“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.”
0:46

Introduction to Jonatan Boguslavsky and Port

Meet Jonatan Boguslavsky, CTO of Port, and learn about the company's mission.

“Jonatan Boguslavsky is the CTO and a co-founder at Port.”
2:07

Jonatan's Background and Career Journey

Jonatan shares his career path leading to the founding of Port.

“Well, let's get started with a little bit of your background.”
3:22

Transitioning to Factory Engineering

Discussion on the evolution from writing features to factory engineering.

“And then how has it evolved for our new agentic era?”
4:35

Understanding the Context Lake

Learn how a context lake structures organizational knowledge for software development.

“So we wanted to create a context for developers.”
5:36

Building Organizational Language for Agents

Explore the need for a shared terminology and structure for agents.

“So the first step, it was that, okay, now I want to ask those things also from my using MCP, from my ID, from cursor, from Cloud Code.”
7:00

Connecting Context to Agents

How to connect different organizational data systems for agent functionality.

“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?”
8:32

Maintaining and Updating the Context Lake

Learn about the processes for keeping the context lake current and relevant.

“So you connect to GitHub, Datadog, Kubernetes, AWS, and you start to map the data to the objects that you created.”
10:31

Dealing with Taxonomy Exceptions

Discuss how to manage exceptions within organizational taxonomies.

“So once you've done your wiring, are you observing changes as they happen?”
12:00

Creating and Implementing Logical MCPs

Explore how logical MCPs function and their role in incident management.

“I am curious to get into this MCP piece.”
Show all 21 chapters
14:00

Iterative Improvement in Incident Management

Learn how iterative improvement plays a role in managing incidents and enhancing tools.

“But the more interesting use case that I want to create something that runs like on every incident, on every PR, on every GR issue.”
18:36

Governance in Software Development

Explore the complexities of governance in the software development lifecycle (SDLC).

“And I'm going to start with one that is unsexy, but everybody seems to be struggling with it, which is governance, right?”
22:09

Monitoring Factory Efficiency

Understand the importance of monitoring to improve factory line efficiency in software development.

“Or how is the execution piece of that workflow happening?”
24:20

Managing Agent Proliferation

Discover strategies for managing the proliferation of software agents within organizations.

“And now we can change the skill to improve the efficiency of the factory.”
27:41

Adapting Port for Different Organization Sizes

Learn how Port can be beneficial for both small and large engineering organizations.

“Like I've worked in a very small environment.”
28:00

Standardizing Software Development with Port

Learn how Port helps standardize software development processes across teams.

“So then it's possible, but it's very difficult to keep the company work in the right way.”
28:34

Understanding the AI Software Factory

Explore the complexities of creating a full software development lifecycle (SDLC).

“And in Port, we give you like some golden path, not only to create an agent, but some golden path out to build your SDLC in the right way.”
29:25

The Role of Engineers in Software Factories

Discuss the evolving role of software engineers in the context of AI-driven factories.

“You need also some agents that learn from the different data that's happening in the factory and improve the factory.”
31:08

Build vs. Buy: Software Factory Infrastructure

Analyze the advantages of building a custom software factory versus purchasing one.

“How the developers, again, they don't be like the feature itself.”
32:56

Future Developments in AI and Port

Speculate on the future advancements and roles of AI in software development.

“that you just like bring your Jira backlog and that's it.”
34:43

Final Thoughts on AI in Software Development

Wrap up with insights on the impact of AI on software engineering efficiency.

“So we wanted the factory, we'll go to the, we'll speak with the support engineer in Slack and ask him the relevant questions.”
A man walking through an airport, asking his phone a question

Ask about this episode

Get the gist, explore an idea or ask about something said.

Claude

On Software Engineering Daily, what are the key points of this episode?

Searching your listening

Transcript

Automatic transcript. May contain errors.

0:00AI 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.

0:46The factory is 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. Jonatan Boguslavsky 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.

1:31Kevin 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.

2:06Jonathan, welcome to the show. Hi. Thank you for having me. 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? 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.

2:46and 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, I will 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, like 100 times bigger. So it's even more challenging, but also more fun. Yeah, that makes sense. So let's maybe talk through what that evolution has looked like.

3:25What was port originally? And then how has it evolved for our new agentic era? Yeah. So I will start with the most simple example. A developer wants a database or S3 bucket, but we can't just give him access to AWS. Like there is so many params, so many things that he can just do mistakes. We want to create some abstraction for the developer that you 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 like three params, but the back-end developer will see 10. And also in each company, so you have abstraction for each persona, but also for each company, you have their own abstraction.

4:03And the developer just fill in the relevant properties and behind the scenes, you can create like a flow that 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, like the self-service and also the context.

4:38So 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 like 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. Got it. So if I'm understanding correctly, you're essentially providing for companies their ability to run internal versions of like 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.

5:14Yeah, 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 are on top of it. 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. Okay, awesome. So now, as you highlight with agents, there's a whole new world here. What has evolved within Port for that? Yeah. So the first step, it was that, okay, now I want to ask those things also from my using MCP, from my ID, from cursor, from Cloud Code.

5:53And 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 like 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-like. Also, the same way you need for developers, the same thing for agents. So 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.

6:39And you want to do a rollback to specific service. So you import, you define what the 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. 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?

7:11How 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? So creating the context lake, it's a couple of stages. So the first stages, as I mentioned, is first of all, you need to create the taxonomy of how everything works. So as I said, like 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. So you define, first of all, the organizational language.

7:45And how structured is that definition? Is that like mapping to deterministic primitives that you have? Or is that like freeform text for an agent or something like that to interpret? So it's like designing ERD in database. You need to configure before you start ingesting data. You first of all, just decide about the objects that you have and the relationship between them. So you say like every service can be deployed on a couple of environments. So you create like a service deployment environment. You create many relations between them. And you really define... So you are kind of building that structured definition.

8:19That's fantastic. Okay, cool. 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 mainly want to be the engineering context. So you connect to GitHub, Datadog, Kubernetes, AWS, and you start to map the data to the objects that you created. So again, I will take the example of service. If you want to map services, So 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. So we give you all the easy ways to configure the data to your language.

8:58Then you also start to connect between the different tools. So you bring like, 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 with the on-call and which pager duty 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. So we give you deterministic rules that you can use them to configure by different labels, different tags. But we also have like auto relation agent that come with suggestion and say, okay, I think those are the owners of the service.

9:36I think this service depends on those service because we took data from Datadog and there is some dependency between them and we also had the API definition. So we think there is dependencies between the services. So we give a lot of suggestion on how you can enrich the context. 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 tools so it will be also easy for the agents to pick the right tools.

10:22So this is the main context. Of course, we can talk also about how to connect MCP connectors and why MCP is still important. Get there. So a couple of different things on this. So 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? Yeah, so we first of all do like a full resync. We bring all the data and then we have like listening to a change in real time. So if 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.

10:54Got it. Okay, that makes sense. Question I had related to taxonomy. So every organization that I've ever worked at, there is like 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? So because sport is so flexible, we also give you a way to handle it. So you can create like maybe in your taxonomy, it's not perfect, but maybe a blueprint for monorepo and a blueprint for not a monorepo.

11:32It'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. So 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.

12:06Yeah, 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. So one, you mentioned we can talk about connectors and MCP and like 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, like 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 like, what does that actually end up looking like from an implementation standpoint? Yeah.

12:36So you, again, as a platform engineer, we give tools to the platform engineer. You can create and import a couple of MCP servers. Really like for the agent, it will look like a completely separate MCP server. And then you can create a MCP server. Let's call it like 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. So instead of like using ports 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 his blueprint identities, he just wants one tool called get current incidents.

13:12So 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 Cloud Managed Agent in Cursor, you can just configure the right one. Got it. And is that something, like I'm trying to think about the life cycle of this. Like, 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?

13:43Yeah, so it's more for things that like happening in a recurring manner. So for example, So 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. So this is one use case. But the more interesting use case that I want to create something that runs like 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. Yeah, that makes sense. Another thing that leads me to is iterative improvement, right?

14:22So if you create one of these, say you have an incident MCP, and I'm a platform engineer and 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. Yes. So we give you analytics on the MCP tools that you use in port. So it's still not easy to always improve only the MCP. Eventually you need to improve a lot of stuff to improve your incident process. It probably is downstream a few steps. Yeah. But yeah, we give you like analytics of which agent uses which tools, if it was successful, if it was not successful.

14:59And then you can, we come with suggestion, but you can also use the data to make decisions by yourself. Got it. So stepping like 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 like 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? Like, what are the different pieces that go into that? And how does Port fit in? So we see that there is a lot of like 10x developers.

15:32It's really like all the engineers can now do like 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 like taking for fixing incidents, for taking features to production, for taking bugs to production. I'm not familiar with companies that are taking features and it goes 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 in prod without human intervention.

16:08But 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? So there is, of course, the model. There is the harness. Now we see all the companies also releasing cloud agents. So Cloud with Cloud Manager, and 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 like 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.

16:49And we can talk like pillar by pillar, but the main pillars in this minfra is like the context that we spoke about, governance, what should happen. So 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. So we give all this experience.

17:22We give the orchestration layer so you can run like from port. We have integration with all those cloud agents that you can trigger. So you can say for the triage process, I want to use cloud. For the coding, I want to use cursor. And for the review, I want to use codecs. So you can easily orchestrate it in port. Then we give also metrics to understand if it's working. Metrics is kind of like 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.

17:59So this is the pillars that we provide. And also an important part that we provide is also the AI registry. We provide you like, we have integration with all the agent platforms. So in Port, you can manage like a certified list of all the agents in your engineering or all the skills or the plugins. And this is, they also part of the context link. So 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. So this is also a flow that we see in Port.

18:34Interesting. 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? So I feel like 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.

19:07So what does governance look like within port? Yeah. So we focus on governance on the SDLC. So by design, the SDLC is kind of every company is different, but you have like kind of the structured process. You have a triage, coding, review. Of course, it can be like 10 stages and always can be a little bit different for bugs, features for different teams get different processes, but you 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. So the way we implement the governance, we first of all, you can create a couple of factory lines.

19:43So you can create factory line for each team can create their own factory line. You can configure like one factory line for those type of bugs, for front end bugs, and another factory line for more docs issues. You can then you define the stages. So 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 up APR. Let's keep it simple.

20:21Of 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 like 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 so we still like can write any code that you want for example but But if you want to do things that are more close to the infrastructure, we need to use port tools.

21:02Then 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. So in order to pass to the next step, it must provide this information. You can decide on each step if there is a need for human approval. And it can be like one human, a couple of humans. It can be a chain if the team leader approved. So now go to the department leader and also approval for him. So we focus a lot on this. So you define those different governance, like different steps and rules that the agent must apply.

21:38You 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 you, we give you a lot of ways to put gadgets in different stages of the SDLC. Got it, that makes sense. So we move for the outer loop of the agents. And are you owning like the execution environment for those agents? Like 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?

22:14So we trigger the tools like load managed agent or a cursor cloud agent. So 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 the Cloud 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. 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?

22:58You run, you get a handoff, and now port is checking a thing. 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 cloud 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 execution. Okay, cool. Yeah, that's a nice division of responsibility. So 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?

23:36So 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. So of course the PRs that were created and all their comments, all the JIRA issues that went through the factory line and the comments there, the agent sessions, the traces, the skills that were used. And then we first of all, just restore it and create like 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.

24:18And then you can run it like on hourly basis, on daily basis, and come with suggestion. And now we can change the skill to improve the efficiency of the factory. Or maybe the efficiency is great, but we just, we can use, instead of use Opus, we can use IQ and it will be the same result. So based on the data, we always come with a suggestion that you can apply it, apply the suggestion. And we monitor eventually like 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. So for example, there is, we see that a lot of features in the factory line are causing incidents.

24:58It's not surprising, But maybe we can make sure that the blast radius agent does a better work. So 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 like more cautious before we deploy. 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 like full agent level evals? Right. Like we've gotten reasonably good at, OK, 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.

25:34And having those end metrics really, really helps with that. yeah 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 like 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 like managing what are all those different things what are they doing is there already something that does what i need is hard what is you mentioned that you have kind of a registry or something like that going on in port like what does that look like so agents as we in In the beginning of the episode, we talked about service catalog.

26:09So like you want to see like 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. So agents is basically the same thing. But again, like one other time is a bigger problem because if a service you create like once a month, once a week, agents, everyone creating a couple of times a day. So first of all, so the way it works, first of all, we have integration with all those different platforms. with Bedrock, Azure Foundry, Cloud, the cursor, we bring like 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 we, from the agents MD and all the configuration that you store there, we also analyze what agents do you have.

26:54Then you can set up a different scorecard. You want to make sure that every service is an owner, every service has description. It uses like models that you want and not like any model. So you define those scorecards. And then you also define like a golden path to create agents. So 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. So 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.

27:29And 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. 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? Like I've worked in a very small environment. We're still like single digit to maybe 10-ish engineers working on a thing. Like 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 like where do you fit in that kind of tech company evolution so the more complexity you have you need port because you have like 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.

28:29So then it's possible, but it's very difficult to keep the company work in the right way. And in Port, we give you like some golden path, not only to create an agent, but some golden path out to build your SDLC in the right way. Of course, it's changing every week, but it's still you have, you always know if you have like big diff between the different teams, if there's some standards, consistency. So we see also small companies want to do it in the right way from the start. Tell me more about how you fit into this competitive landscape and this new category of an AI software factory. Yeah. So we see that there is to create a full SDLC of taking feature to production is a complex process.

29:10So I described pretty naively in the beginning that there is like 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 contacts 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. You want also to sometimes you want to create with like no deterministic stuff. For example, you have a long list of PRs that are stuck and you want to nudge to the relevant developers. Maybe there is something in PR and you get like new info from the PM and you want to bring it back to the triage process.

29:50So 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 like doing the work itself. So 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 like every company wants it but like coding agent companies like devin for example or cursor they're focusing like how to build the best target as the best agent but there is a lot of layer on top of it that you want to make sure not only the developer itself becoming like 10x better but they all becomes 10x better and this is where port comes in yeah so So that kind of points to this interesting question around, like, what is the role of an engineer in this new world?

30:45What is happening with software engineers, you know, in the world that port is enabling? It's a big transition. So still, like, developers are writing the code, and I think it's still, like, there. And the complex part of the code, they are still going, like, to, they'll be responsible on creating, like, the new design architecture, the complex feature. They will take part of the product work. But also like a new third number, factory engineering. How the developers, again, they don't be like the feature itself. They're building the factory line to make sure the agents can deliver the feature in the best way.

31:20So they see like they write the skills, they provide the context, they're writing evils. And eventually we want from every feature that produces an incident to create from this feature and incident to create an evil. So 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. And I feel like some people are investing in the factories and they're saying, hey, this is a competitive advantage for us.

31:54We're going to be better at this than everyone else. Obviously, you're saying, hey, like this is its own specialty. You should outsource the 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? Yeah. So 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, the way, how much they want to give to autonomy for agents, how much guardrails they want to put, what kind of they deploy every minute or they deploy once a week.

32:36So 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. So I don't think that you can buy just a software factory, a software factory product out of the shelf that you just like bring your Jira backlog and that's it. To your company, you need to build it. And we see like you build with port, the same kind of like you build with Lavable website. So you build with port, the factory lines. So a lot of things you want to own, like writing the skills themselves, writing the evils, deciding about the taxonomy of your organization.

33:19So you want to build it, but you don't want to manage like all the RBAC to decide which tools each agent can access, switch 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. 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? Like 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?

33:57What are you tackling next? And where do you see this going? So we really believe that you can get to it. 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 help to more and more companies to get to it. What we see next. So eventually there is a lot of still, it's not a dark factor. It's not like just you put the agents and they do all the work and the human, like we don't need them.

34:29There 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 go to the, 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.

35:05So maybe we want to add both those product managers to the factory and try to get, again, the relevant context for the coding agent to make the right decisions. So are we to make it more, to handle those not epiflow 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. 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? I don't think so. It's really exciting times. Every week there is something new and we see like the platform teams, the AI excellence teams, like they are responsible of bringing the AI to SDLC.

35:46and it's really like fascinating to work with those teams and to make the 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.

From the publisher

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 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.

Full Disclosure: This episode is sponsored by Port

Sponsorship inquiries:
[email protected]

The post The Rise of the Software Factories appeared first on Software Engineering Daily.

More from Software Engineering Daily

All episodes