ソフトウェアファクトリーの台頭:個人の生産性をどう組織の成果に変えるか

The Rise of the Software Factories

Software Engineering Daily36分
ソフトウェアファクトリーの台頭:個人の生産性をどう組織の成果に変えるか

ソフトウェアファクトリーの台頭:個人の生産性をどう組織の成果に変えるか

Software Engineering Daily

0:0036:19

要約

Port の共同創業者兼 CTO の Yonatan Boguslavsky が、Kevin Ball とともに AI ソフトウェアファクトリーについて語った回。コーディングエージェントで個人は 10 倍になっても組織全体では 1.2 倍程度にとどまるという課題に対し、コンテキストレイク、ガバナンス、人間による承認、オーケストレーション、メトリクスを備えた「ファクトリーライン」を構築する考え方を紹介している。エンジニアの役割が「ファクトリーエンジニアリング」へ移ることや、構築か購入かという問いにも触れている。

この回のポイント

  • ●Boguslavsky は、エンジニア個人は 10 倍働けるようになったが組織としては 1.2 倍程度にとどまると述べ、機能を本番に出すまでの工程全体の整備が必要だと主張している。
  • ●コンテキストレイクは、service や environment などの組織固有の用語を ERD のように先に定義し、GitHub・Datadog・Kubernetes 等のデータをそのオブジェクトにマッピングして作る。
  • ●用途別の「論理 MCP」により、インシデント対応など繰り返し発生する場面に必要なデータとツール名だけをエージェントに見せられる。
  • ●ガバナンスはファクトリーラインとして、トリアージ・コーディング・レビューなどの段階ごとに担当エージェント、使えるスキル、出力 JSON、スコアカード、人間の承認チェーンを定義して実現する。
  • ●実行環境は Claude の managed agents や Cursor の cloud agents などに任せ、Port は上位でオーケストレーションと監視を担う。モデルやエージェントには依存しない。
  • ●エンジニアの役割はスキル、コンテキスト、評価(eval)を書いてファクトリーを改善する「ファクトリーエンジニアリング」に移ると述べている。ファクトリーは既製品を買うものではなく、自社で構築するものだという立場である。

章立て

  1. Port の背景と成り立ち

    Boguslavsky のイスラエル諜報部隊でのプラットフォーム経験と、開発者セルフサービスとしての Port の原点を紹介する。

  2. エージェント時代の Port とコンテキストレイク

    組織固有の言語(タクソノミー)を定義し、各種ツールのデータをマッピングしてエージェントに公開する流れを説明する。

  3. 論理 MCP と分類の例外処理

    用途別に切り出した MCP サーバー、リアルタイム同期、スコアカードによる理想と現実のギャップへの対処を語る。

  4. ソフトウェアファクトリーの柱

    10 倍の個人と 1.2 倍の組織という落差を背景に、コンテキスト、ガバナンス、承認、オーケストレーション、メトリクス、AI レジストリを概説する。

  5. ガバナンスと監視の実装

    ファクトリーラインの段階定義、人間の承認、実行環境の責任分担、セッションデータによる継続的改善を議論する。

  6. エージェントレジストリと導入規模

    エージェントの乱立を管理する仕組みやゴールデンパス、小規模組織での適用についてまとめる。

  7. 競合領域とエンジニアの役割、構築か購入か

    コーディングエージェントの上位レイヤーという位置づけ、ファクトリーエンジニアリング、自前構築すべき領域を述べる。

  8. 今後の展望

    バグゼロを目指す構想と、人間に不足情報を問い合わせるプロアクティブなエージェントの方向性を語る。

解説記事

AI コーディングエージェントによって開発者個人の生産性は大きく上がったが、会社全体の成果はそれほど伸びていない。Software Engineering Daily のこの回では、Port の共同創業者兼 CTO の Yonatan Boguslavsky が Kevin Ball の質問に答え、その溝を埋める「ソフトウェアファクトリー」の考え方を語った。なお本エピソードは Port がスポンサーであり、以下は Boguslavsky の主張として整理している。

個人は10倍、組織は1.2倍という課題

Boguslavsky は、今やエンジニア個人は約 10 倍の仕事ができるが、組織としては 1.2 倍程度にとどまっていると述べている。理由は、機能を本番に届けるまでにトリアージ、レビュー、コンテキスト、ガードレール、人間の承認など多くの工程があるからだという。人手を介さずに機能が本番まで届く状態は「夢」であり、コーディングエージェントは一部の機能でそれを可能にし始めているが、特にエンタープライズでは管理された堅牢な仕組みが要る、という見方を示した。

Port の出発点は、開発者向けのセルフサービスだった。DB やバケットが欲しい開発者に AWS を直接触らせず、ペルソナごとに必要最小限のパラメータだけを見せ、裏では Terraform の pull request などを生成する。エージェント時代には、この仕組みを MCP 経由で IDE やエージェントからも使えるようにし、問題は「100 倍大きくなった」と表現している。

コンテキストレイク:組織の言語を定義する

中核となるのがコンテキストレイクである。まず service、environment、workload といった言葉が自社で何を意味するのかを、データベースの ERD を設計するようにオブジェクトと関係として定義する。次に GitHub、Datadog、Kubernetes、AWS などからデータを取り込み、モノレポならフォルダ、そうでなければリポジトリを service に対応づけるといったマッピングを行う。Jira、PagerDuty、CODEOWNERS を結びつけて、所有チームやオンコール担当を引けるようにもする。

関係の推定には決定論的なルールに加え、依存関係や所有者を提案する自動関連付けエージェントも使う。同期は最初に全件取り込み、その後は変更をリアルタイムに検知する。理想的な分類に合わない既存の技術的負債には、モノレポ用と非モノレポ用でブループリントを分けるといった中間策や、スコアカードとイニシアチブで Slack や Teams からタグ付けを促す方法で対処するという。

公開面では「論理 MCP」が特徴だ。全データを渡すのではなく、たとえばインシデント対応用に get current incidents のようなツール名と必要なデータだけを持つ MCP サーバーを作れる。エージェントからは独立した別サーバーに見える。人気の用途は、すべてのインシデントや PR で走る繰り返しのクエリを最適化することだという。

ファクトリーラインとガバナンス

ガバナンスは SDLC(ソフトウェア開発ライフサイクル)に焦点を当てる。チームごと、バグや機能などの種別ごとに「ファクトリーライン」を作り、トリアージ、PR 作成、影響範囲(blast radius)の評価、QA、レビューといった段階を定義する。各段階には担当エージェント、使えるスキルとツール、次へ進むために出力すべき JSON(重大度や担当者など)を設定する。

さらに人間の承認を 1 人または連鎖(チームリーダー、次に部門長)で挟める。スコアカードで「稼働時間内かつ現在インシデントゼロのときだけデプロイ可」といった決定論的な条件も置ける。実行自体は Claude の managed agents や Cursor の cloud agents などに任せ、環境の責任はそちら(またはユーザー)が持つ。Port は設定をコードとして管理し、ログや状況を監視する分担である。

閉ループによる改善とエージェントの登録管理

ファクトリーを「チケットやインシデントを通すたびに賢くなる」閉ループにすることを重視している。PR とコメント、Jira、エージェントのセッションやトレース、使われたスキルを蓄積し、分析エージェントが定期的に改善案を出す。スキルの修正や、Opus を軽量モデルに替えても結果が同じなら置き換える、といった提案が例に挙がった。機能がインシデントを起こしがちなら、コンテキストに依存関係を加えて影響範囲評価を強化する。Ball は、連鎖したエージェント全体の評価は難しく、最終的なメトリクスがそれを助けると指摘した。

エージェントの乱立には、サービスカタログと同様のレジストリで対応する。Bedrock、Azure Foundry、Cursor などと連携し、ローカルのエージェントも agents.md から把握する。スコアカードで所有者や説明、使用モデルを検査し、認定済みスキルや MCP だけで作る「ゴールデンパス」を用意するという。

エンジニアの役割と構築か購入か

Boguslavsky は、複雑な設計やアーキテクチャは引き続き開発者の仕事だが、新たに「ファクトリーエンジニアリング」が加わると述べる。スキルを書き、コンテキストを整え、評価を書く仕事で、インシデントを起こした機能から eval を作れば次回はエージェントがうまく動ける。Port は Devin や Cursor のようなコーディングエージェントの上位レイヤーだと位置づけている。

構築か購入かについては、どの会社も固有の事情を持つため、完成品のソフトウェアファクトリーを買うことはできないという立場だ。スキル、eval、タクソノミーは自社で持つべきで、RBAC、エージェントの起動、監視といった基盤部分は Port のようなツールに任せられる。今後は、不足情報を Slack で support engineer に聞き返したり、矛盾する仕様を持つ PM 同士を巻き込んだりする、よりプロアクティブなエージェントを目指すと語った。

まとめ

個人の生産性向上を組織の成果につなげるには、コード生成だけでなく、コンテキスト、ガードレール、承認、評価を含む工程全体を設計する必要がある、というのが本回の主張である。日本の現場でも、エージェント導入が進むほど「どの工程にどの権限を与え、どこで人が確認するか」が問われるだろう。ファクトリーを自社で作り込む部分と基盤に任せる部分の線引きが、プラットフォームチームの重要な論点になりそうだ。ただし数値や効果は発言者本人の見方であり、自社環境での検証が前提となる。

文字起こし(英語・自動生成)

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 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. Kevin Ball, or Kate Ball, 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.

Jonathan, 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 have the platform info team to make sure that we keep our standards, that they don't do like 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, OK, 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 would give the best tools for the platform engineers to build the platform that they expose the 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. What was Port originally, and then how has it evolved for our new agentic era? Yeah, so I will start with the most simple example. Well, a developer wants a database or a free bucket, but we can't just give him access to AWS. Like 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 like three params, but the back-end developer will see 10. And also each company, so 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 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 gets 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 secrets, for adding feature flag. So this is one part, like 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. 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. 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 are on top of it.

So you choose the way it works, 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 was that, okay, now I want to ask those things also using MCP, from my ID, from Carouser, from CloudCode. 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 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-sealing 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 specific service. So you import to 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 regates this specific GitHub workflow or do this specific tool 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? 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? So creating the context link, it's a couple of stages.

So the first stage, as I mentioned, is first of all, you need to create the taxonomy of how everything works. So as I said, what is service, what environment, what is deployment, what is workload, workload is algo application, it's Lambda, it's new-way service, but you need to define what it means in your organization. So you define, first of all, the organizational language. And 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. So you are kind of building that structured definition. That'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, Datadour, 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. Then you also start to connect between the different tools So you bring like let 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. So we give you deterministic rules that you can use them to configure by different labels,

different tasks, but we also have like 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 dependency between the services. So we give a lot of suggestion on how you can enrich the context. Then once you have the data, agents 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 so this is the main context stack 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 the real time. So with some pod, you keep 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. Got 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 port is so flexible, we also give you a way to handle it. So you can create like maybe in your top-sonomy 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. 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 matches on Slack, on Teams to the different teams to put the relevant apps. 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. Yeah, nice. Okay, I am curious to get into this MCP piece. So there's a couple of 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, so you, again, as a platform engineer, we give tools to the platform engineer. You can create a couple of MCP servers. Really, like, for the agent, it will look like a completely separate MCP server. and then you can create an 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. 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 M6 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 lifecycle 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? Yeah, 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? So 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, like, 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 I don't have, like, it's still not easy to always to improve only the MCP. Eventually you need to improve a lot of stuff to improve your internet 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. And then you can, we come with suggestion, but you can also use the data to make decisions by yourself. Got it. So 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? So we see that there is a lot of like 10X developers. It'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 back to production. I'm not familiar with companies that taking like 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? 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 Kersler 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,

earnest 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 gathered way. And 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. He 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. We 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 triad 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 so this is the pillars that we provide and also 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. 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. 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?

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. So what does governance look like within port? Yeah. So we focus on governance on the SDLC. So by designing the SDLC, it's 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 teams have some structure already in place. It's difficult to make sure in a deterministic way that the agents apply those rules, but you have some structure. So the way we implement the governance, first of all, you can create a couple of factory lines. So you can create a 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, and another factory line for more docs issues. 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 it up APR. Let's keep it simple. Of course, then I can add more agents 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 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 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 both 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. so in order to pass to the next step he 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, couple of humans it can be a chain if the team leader approves 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 you can configure scorecards on each step, 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 targets 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? So 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 a close code CLI on the GitHub workflow and it's also a way to But we give 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? You run, you get a handoff, and now port is checking the 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 end. 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? So one of the most important things 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 saw 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. And 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 slate, approved.

So, 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. 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, 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, 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? It's hard. You mentioned that you have kind of a registry or something like that going on in port. What does that look like? So agents, as 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. So agents is basically the same thing, but again, one hundred times 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 select 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 there.

Then you can set up a different scorecard. You want to make sure that every service has an owner, every service has a 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 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 Spokal, 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 work 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 gardens 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 garbage. So 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 deals 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 like how you fit into this competitive landscape and this new category of like an AI software factory.

Yeah. So we see that there is to create a full FVLC of taking like feature to production is a complex process. So I described pretty nicely in the beginning that there is like a triage opening a PR to review it. But there is a lot of like things that should happen in this simple process. A lot of guardrails, a lot of context 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 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. So a lot of things happening and a lot of things that you need to handle in this process. Ford 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 Kerser, they're focusing like how to build the best talent 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 become 10x better, and this is where both comes in. Yeah. So 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, 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, and the complex part of the code, they are still going, like, to, they are being responsible on creating, like, the new design architecture,

the complex feature. They will take part of the product work. But they're also, like, a new turn now by 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. So they see, like, 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. 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. We'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. Like what does the build versus buy look like here

and what is the case for like, hey, this is infrastructure that we should, you know, 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 cables they want to put, what kind, they deploy every minute, or they deploy once a week. So 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 bring your Jira backlog and that's it to your company. You need to build it. And we see you build with Poe, 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 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 parts 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? 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? So we really believe that you can get to it. It's very difficult, but you can't 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 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 factory. It's not like just you put the agents and they do all the work and the human, like we don't need them. There is still a lot of interaction between a human and agents, It's 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 realize 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 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 epi-flow situations 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, they are responsible of bringing the AI to SDLC. And it's really fascinating to work with those teams and to make the 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

番組の概要欄(原文)

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: sponsor@softwareengineeringdaily.com The post The Rise of the Software Factories appeared first on Software Engineering Daily.

出典・この記事について

番組
Software Engineering Daily(Software Engineering Daily)
元の回
The Rise of the Software Factories
配信日
要約作成日
公式サイト
softwareengineeringdaily.com

この要約・解説記事は、元の音声を文字起こしした内容をもとに AI(Claude)が日本語で作成したものです。 固有名詞や数値に誤りを含む場合があるため、正確な内容は元の音声でご確認ください。制作方法について

X でシェア

関連エピソード