This article is an English version of a post I contributed to the AWS Blog (Japanese).
Introduction
Hello, I'm Kento Ikeda, Representative of BrightFlow LLC. I have been an AWS Community Builder in the DevTools category since 2021.
BrightFlow supports companies' engineering work as an external CTO and technical advisor, and also builds its own product. In our product development, we use AI extensively, and we also experiment with how the development process itself is run. Sharing what we learn along the way, as in this article, is part of that experiment.
Having AI agents write code and open pull requests (PRs) is no longer unusual. The more we delegate, the less the question is about model capability and the more it is about boundaries:
- Who decides the task, who can request a write, and who actually writes?
- When an agent says "done" or "tests passed", what do we accept as fact?
- Can we verify afterwards what was reviewed and what was merged?
There are now many ways to combine AI agents. You can have two coding agents talk to each other, or, as with Kiro, use official features to run multiple agents in stages. This article is not about how to combine agents. It is about where to place the boundaries when you let combined agents write: who holds the permissions, how far changes may go, and under what conditions a change gets merged.
To develop our product, I built a system that uses Kiro CLI as the implementer (BRIDGE from here on) and ran it for about a month. In this article, I describe why I built BRIDGE, its architecture and four boundaries, what I learned from running it, and finally how it compares with Kiro's built-in features as of October 2026.
Note: The setup described here is from my own environment and is not a configuration recommended by AWS. See the "Terms of use" section at the end.
1. Why I built BRIDGE
I started building BRIDGE at the end of August 2026. By then, Kiro Web (preview released on May 7, 2026), which works autonomously in the cloud, and Kiro Crew (released on August 4, 2026), which you self-host and keep running, were already available. So my reason for building my own was not that the official features made it technically impossible.
I built it because I had decided on three ways of working first:
- Combine the strengths of two different AIs and run them as a team. Just as a human development team splits roles between design and implementation, I wanted an AI that plans and reviews to work with Kiro as the implementer. It is a lightweight form of orchestration. The planning AI gathers information from outside the repository, such as documents, tickets, and web content, through apps and connectors added to that AI. It then hands Kiro, which is good at implementation, a well-organized request. I designed the planning AI to be replaceable by any MCP-capable AI so that it would not be tied to a specific product.
- Keep humans watching what they should watch, and delegate the rest for efficiency. Humans step in for direction-setting decisions and when the AI gets stuck. The rest of the routine flow goes through AI review all the way to merge.
- Let expected changes proceed, and stop on unexpected ones. When the files to be changed are obvious from the request, the work can proceed without waiting for confirmation. When changes reach files nobody expected, the work should stop automatically for review.
The first point is also exactly why boundaries are needed. Information that the planning AI collects from external apps is input whose content I cannot control. Since Kiro acts on requests written from that information, the system has to decide what may be written and under what conditions a merge happens, regardless of the request.
If you only want two agents to talk to each other locally, you do not need to build anything. In that case, however, both agents almost always run in the same environment with the same credentials. What I needed was a system that does not give write credentials to the planning AI and that fixes the write paths and conditions in the system itself. I used Kiro as the implementer, but this approach applies no matter which agents you combine.
2. BRIDGE architecture and four boundaries
Overall architecture
BRIDGE consists of an MCP (Model Context Protocol) server that the chat-side AI connects to, and a controller behind it that runs the implementation.
On the chat side, in principle any client that can connect to a remote MCP server works. ChatGPT custom MCP apps and Claude custom connectors are two examples. I actually used ChatGPT, and all numbers and incidents in this article come from using BRIDGE through ChatGPT.

Figure 1: Architecture and boundaries. Only the Dev Controller holds GitHub and Kiro credentials.
BRIDGE connects to Kiro in two ways. On the READ path, it opens a Kiro session over the Agent Client Protocol (ACP) and only has Kiro read the repository's configuration files (steering files). On the WRITE path, it runs Kiro CLI in headless mode and receives the output in stream-json format. BRIDGE uses Kiro CLI 2.21.x (V2 engine).
The flow from request to merge is as follows.

Figure 2: Flow from request to merge.
Where humans were involved
- Starting work and making decisions: I started each piece of work by making a request in the chat. After that, the AI called tools in sequence, and I gave instructions when the AI stopped or a decision was needed.
- Executing writes: I set the chat client's tool confirmation to "always allow". I did not turn off confirmations so that I could hand over everything. Because the boundaries described below were built into the system, turning off confirmations does not change what the AI can request. Writes are limited to the scope declared for each request, execution is confined to a sandbox, and only a PR with the specified HEAD can be merged. By having the system enforce boundaries instead of having a human judge each operation, I balanced the freedom given to the AI against safety. On the other hand, whether the changes were correct was left to AI review and verification. I return to this in Lesson 4 of Section 3.
- Features used: On the chat side, I used the custom MCP connection feature provided by the client. On the Kiro side, I used the official Kiro CLI.
Boundary 1: Do not hand over credentials, and fix the operations that can be requested
When you let an agent write, the first thing to decide is who holds the write credentials. If the agent itself holds a GitHub token or cloud credentials, it can write anywhere, depending on how it interprets instructions. However, not holding credentials is not the same as not being able to write. It only becomes a boundary once the types of operations and their arguments are fixed as well.
In BRIDGE, the chat-side AI holds neither a GitHub token nor a Kiro API key. All it has is a way to call five tools.
| Tool | Path | Role |
|---|---|---|
inspect_app |
READ | Check repository status |
inspect_pr |
READ | Get PR metadata and diff |
execute_dev_task |
WRITE | Delegate a development task to Kiro, and open a PR if it passes verification |
merge_pr_and_sync |
WRITE | Merge only if the specified HEAD SHA matches, then sync |
inspect_dev_task |
WRITE | Check a task's execution status |
The target repository, base branch, and merge method are fixed on the server and cannot be specified from the chat side.
I separated READ and WRITE at three levels: the URL, the OAuth scope, and the chat-side connection settings (separate apps for READ and WRITE). The URLs for READ and WRITE each contain a different secret value. This secret is not a substitute for authentication. Tool execution always requires OAuth authentication. The URL secret is an aid that narrows what is visible from outside by returning 404 for every other path. Because the URLs contain secrets, access logs are not recorded.
Boundary 2: Decide the allowed scope of changes up front, and verify it afterwards
"Do not touch any other files" is an expectation, not a guarantee. The allowed scope of changes needs to be decided up front in a machine-readable form and checked against the actual diff after the work.
In BRIDGE, when the chat-side AI calls execute_dev_task, it must declare, along with the instructions, which files may be created, modified, or deleted.
{
"taskId": "example-task-001",
"baseCommit": "<40-character commit SHA>",
"instruction": "…",
"verifierProfile": "test",
"changePolicy": {
"allowedChanges": [
{ "path": "app/src/example.ts", "type": "modify" },
{ "path": "app/src/example.test.ts", "type": "create" }
]
}
}
After Kiro runs, the Dev Controller observes the actual diff in the workspace and fails the task if there is even one change that was not declared. This check is how the third way of working from Section 1 is implemented: expected changes proceed, and only unexpected changes stop the work.
Boundary 3: What stops writes is the execution environment, not the agent's own report
Agents report what they did. But if you decide whether a write is allowed by looking at that report, the decision breaks when the output format changes or the agent does something unexpected. Treat the output as a record for later verification, and let the execution environment (a sandbox) set the upper limit on writes.
BRIDGE runs the entire Kiro CLI process in a sandbox built with Linux bubblewrap and seccomp. As a result, not only shell commands but also writes through Kiro's built-in file tools are confined at the OS level to a disposable workspace. If a sandbox cannot be set up, Kiro is not started. The only tools pre-approved for Kiro are read, grep, glob, and write, and shell execution is not allowed. (These are Kiro CLI 2.x tool names. In V3, they were renamed to names such as read_file and grep_search.) The stream-json output is recorded but not used to decide whether a write is allowed.
The Kiro CLI version BRIDGE used (2.21.x) did not yet have Kiro's local command sandbox, which I describe later.
Boundary 4: Fix what was reviewed and what gets merged
A PR can be updated after review. At merge time, you need to confirm at least that the HEAD of the reviewed PR and the HEAD of the PR being merged are the same. In addition, if the target branch has moved forward, the post-merge state differs from what was reviewed.
In BRIDGE, a merge request can specify only the PR number and the HEAD SHA at review time (expectedHeadSha). The Dev Controller fetches the PR again and confirms that BRIDGE created it, that it is not a draft, and that GitHub reports no conflicts. It then passes expectedHeadSha as sha to the GitHub merge API. If the HEAD has moved, GitHub rejects the merge. Because BRIDGE merges based on AI review rather than GitHub approvals, it checks the HEAD SHA match itself instead of relying on branch protection's approval settings.
After merging, BRIDGE syncs the repository on the server and returns the latest main SHA and whether the merge commit is reachable. It reports "merged but sync failed" separately from "not merged", so that the calling AI does not misread the result and repeat the operation.
Merging and syncing became a single step because of something that happened right after operation began. After a PR was merged on GitHub, the repository on the server stayed out of date, and the next task started work based on an old commit. That task was stopped when the base mismatch was detected at PR creation. Since then, merging and syncing have been handled as one step rather than two.
Size
BRIDGE grew to about 49,000 lines of TypeScript (about half of it tests). That is because each stage of writing (creating the workspace, running in the sandbox, checking the scope of changes, freezing the artifact, verification, and PR creation) checks things independently without trusting the result of the previous stage.
3. What I learned from running it for a month
This section first presents the PR statistics, then the lessons drawn from them, and finally the incidents that actually happened during operation.
3.1 PR statistics
I collected about one month of PRs, from the start of operation, in the repository of the product we developed with BRIDGE.
| Status | Count |
|---|---|
| Merged | 317 (about 51%) |
| Closed (not merged) | 159 (about 25%) |
| Open | 148 (about 24%) |
About half were not merged. When I examined the 307 unmerged PRs one by one, most of them were not PRs that had been rejected in review.
| Reason not merged | Count |
|---|---|
| The PR has no diff at all | 122 |
| Connectivity-check PR | 9 |
| Same content as an already-merged PR | 2 |
| A later PR for the same work was merged (*1) | 37 |
| Conflicts with main at the time of collection | 81 |
| Applies cleanly to main at the time of collection but not merged (*2) | 56 |
| Total | 307 |
Collection period: September 11 to October 12, 2026 (state as of October 12, 2026). Each PR is counted under the first reason that applies, checked from the top row down.
*1 Includes estimates based on PR names.
*2 About 20 of these appear to be PRs that only wrote investigation results to files (estimated from file names).
PRs with no diff, connectivity checks, identical content, and those superseded by a later merged PR add up to 170. More than half of the unmerged PRs never needed to be merged in the first place.
Each BRIDGE PR consists of a single commit whose parent is the base at creation time. I checked whether a PR had a diff in two ways: by comparing the tree of that commit with the tree of the base, and by the number of changed files GitHub reports for the PR.
3.2 Lessons from operation
Here are four lessons from the statistics, each with a way to address it.
Lesson 1: Work that only has a write path will be done through the write path
The READ path's inspect_app could only return the repository status and the result of checking configuration files. There was no path for reading code and answering questions. As a result, the chat-side AI used execute_dev_task even for tasks such as reconciliation, auditing, and confirmation. When Kiro finished without changing anything, a PR with no changes was created. There were also PRs that wrote investigation results to the repository as text files.
The boundaries themselves were never broken during this time. Investigation tasks also ran within the declared scope of changes and inside the sandbox, and no unauthorized writes occurred. The problem was that the read path was insufficient, so the path meant for writing was also used for investigation, increasing PRs with no changes and PRs that only contained investigation results.
The more strictly you restrict writes, the more broadly you need to provide read paths. Otherwise, the write path gets used for investigation.
How to address it: Separate investigation and confirmation into a path that is completed with reads only. In Kiro, Workflows' investigate recipe, which investigates without changing source and returns a report, or Permissions settings that do not allow writes, can play this role. The key is to receive investigation results as a report instead of writing them to the repository.
Lesson 2: If creating a PR is the completion condition, PRs become an input/output channel
BRIDGE created a PR even when there were no changes, because the PR doubled as the task completion notice. For tasks with no changes, it should have returned only the result without creating a PR.
How to address it: Add "there is a diff" as a condition for creating a PR, and return only the result for tasks without a diff. Then PRs with no changes are never created. In addition, a mechanism that regularly detects PRs with no diff, duplicate PRs, and PRs left in conflict with main helps prevent PRs from piling up.
After writing the original article, I cleaned up the unmerged PRs created during the collection period. Closing PRs in bulk is an operation that is hard to undo. So I had the AI draft the cleanup policy and the commands, and I ran them after reviewing them. I did not close PRs based on their number or age alone; I closed them after comparing them with later PRs for the same work and checking their diff against the current main. Three small changes that were still needed turned up in the process, and I recreated them with BRIDGE against the current main and merged them. All unmerged PRs from the collection period have now been cleaned up.
Lesson 3: Minimal logging to protect secrets makes it impossible to measure the effect of boundaries
To avoid leaking paths, file contents, or tokens, the Dev Controller was designed to log only fixed strings. Task results (failures due to undeclared changes, merge rejections due to SHA mismatches, and so on) were only returned to the chat side as responses and were not recorded on the server.
As a result, I could not count afterwards how many times Boundary 2 and Boundary 4 actually stopped processing. I should have recorded, from the start, the types of results and their counts, which contain no secrets.
How to address it: Do not record paths or file contents, but record the result types (success, undeclared change, SHA mismatch, and so on) and their counts. Then you can count the effect of boundaries without leaking secrets. These two goals are compatible.
Lesson 4: If you automate AI review, design the scope and record of that review
The median time from PR creation to merge for merged PRs was 32 seconds. About half were merged within 30 seconds of creation, and more than 80% within 10 minutes. There were zero GitHub reviews, and review decisions remained only in the chat conversation. Because the confirmation for write tools was set to "always allow", most merges were executed based only on AI review, without my approval each time. I did not record how much of each PR's diff I read myself, so this cannot be measured. It is reasonable to assume that PRs merged within tens of seconds relied on the AI's review.
The input to review also had limits. The diff returned by inspect_pr is capped at 8 KiB per file, 50 files, and 128 KiB in total, and a truncation flag is set when it exceeds those limits. The AI may not have seen all the changes.
Running BRIDGE also revealed a limit in how Boundary 4 was implemented. More than 90% of merged PRs were merged into the same main they were created from. In that case, the contents of main after the merge are the same as the state BRIDGE verified before creating the PR. On the other hand, about 6% (19 PRs) were merged after main had moved forward following review. For these 19 PRs, I compared the files each PR changed with the files changed on main after the review, and found no overlap. There is also no record of the changes being reverted afterwards. Even so, the post-merge state of these 19 PRs went into main without being verified. They should have been verified again against the latest main before merging.
How to address it: Add the following three conditions for merging to cover this limit.
- CI build and tests pass against the latest main
- The diff used for review was not truncated
- The review decision and its rationale are kept somewhere that can be referred to later, such as the PR
If you switch to having humans approve merges, GitHub branch protection (see Section 4) can satisfy the first condition.
3.3 Incidents during operation
Here are two incidents that happened during operation and could occur in any setup that connects an external AI client to an MCP server.
Incident 1: Starting OAuth and fetching the tool list were waiting on each other
This incident happened with a ChatGPT custom MCP app, but it involves issues common to connecting an OAuth-protected MCP server to external clients.
When I created the ChatGPT custom MCP app, it showed zero tools, and OAuth account linking never started.
Two causes overlapped. The first was that the per-tool authentication declarations were not reaching ChatGPT. ChatGPT looks at each tool's securitySchemes in the tool list (tools/list) to decide which authentication is required. The official MCP TypeScript SDK I used (@modelcontextprotocol/server 2.0.0) strips unknown keys from tool definitions, so writing securitySchemes directly did not make it into the response. The second was that BRIDGE did not return tools/list unless the request was authenticated. ChatGPT starts authentication after seeing the tool list, and BRIDGE did not return the tool list until authentication was complete. Each was waiting for the other.
I addressed it as follows.
- I declared
securitySchemesinside_meta, which the SDK does not strip, and added a step that copies that value tosecuritySchemesdirectly under each tool just before returning thetools/listresponse. This step only changes the shape of thetools/listresponse and does not touch tool execution or authentication decisions. The WRITE path builds its tool list response itself, so it places the value directly under each tool from the start. READ tools require only the read scope, and WRITE tools require only the write scope. - I limited what is allowed without authentication to just three methods:
initialize,notifications/initialized, andtools/list. Requests with invalid tokens or tokens with the wrong scope are rejected instead of being downgraded to anonymous. - For unauthenticated
tools/call, BRIDGE returns a tool error containing_meta["mcp/www_authenticate"]so that ChatGPT can start authentication.
In production, I confirmed that initialize and tools/list succeed, that the READ tool list contains only the two READ tools, and that an unauthenticated tools/call returns an error prompting authentication.
One constraint remains: tool names and input schemas are visible without authentication to anyone who knows the URL. The secret in the URL narrows who can see them, but it is only an aid that limits visibility. Tool execution is still protected by OAuth authentication.
Incident 2: Long-running tools collided with MCP client retries
The READ path's inspect_app sometimes took about 60 seconds to complete. The outer MCP client retried the same request after about 60 seconds, and the retry collided with the original request still in progress and received a "busy" error. The same happened with the implementation tool execute_dev_task: each retry was assigned a new task ID and rejected as a second task with a "busy" error, while the original task kept running.
execute_dev_task is a synchronous tool that completes everything from implementation to PR creation in a single call. I addressed this problem not by rebuilding the call as asynchronous, but by keeping it synchronous and adding what was missing.
First, instead of rejecting retries, BRIDGE now joins them to the operation in progress and returns the same result (single-flight). Whether two requests are the same is determined by the request contents, not by an automatically assigned task ID. Requests with different contents are still rejected as "busy". I also raised the time limit for implementation in steps from 120 seconds to 600 seconds. In production, I confirmed that a retry arriving about a minute later joined the operation in progress without starting a new task.
Even so, if the chat side timed out while waiting for a response, there was no way to tell whether the task was still running or had finished. So I added inspect_dev_task, which reports the status (running or completed) for a given task ID. This made it possible to check the result after a timeout without running the same request again.
As a result, the setup now normally receives results synchronously and checks status only when a response is lost. Looking back, being able to finish everything through PR creation in a single call, without repeatedly checking status, was an advantage of the synchronous design. On the other hand, as long as long-running work is exposed synchronously, the interaction with client-side timeouts remains. If you build something like this, it is worth considering from the start an asynchronous design that returns only the start of execution and checks status with a separate tool.
4. Comparison with Kiro's built-in features
Even in the roughly two months between late August 2026, when I started building BRIDGE, and October 2026, when I wrote this article, Kiro gained new features. For example, Workflows, which runs each step in an independent agent session, became available on September 30, 2026 in Kiro CLI (2.26.0) and Kiro Web.
In this section, I look at how much of BRIDGE's four boundaries and the lessons from operation can be achieved with Kiro's built-in features as of October 2026. Everything here is limited to what I could confirm in the official documentation.
The four boundaries and Kiro's features
Boundary 1 (Do not hand over credentials, and fix the operations that can be requested): With Permissions, you can set allow, ask, or deny for each operation the agent can use (reading and writing files, shell, MCP, and so on). Deny always takes precedence, and the settings can be embedded in an agent's configuration. This lets you configure per role, for example by giving a reviewer agent no write access.
Boundary 2 (Decide the allowed scope of changes up front, and verify it afterwards): The up-front part can be done with Permissions. You can specify the paths that fs_write may write to with globs, and in headless mode every operation that would require confirmation is treated as denied, so the agent cannot write outside the explicitly allowed scope. The after-the-fact verification is something you build in yourself. Using Hooks, which can run a command when the agent finishes, or CI that checks the files changed in a PR, you add a step that compares the allowed scope with the actual diff. BRIDGE implements this verification itself, including per-request declarations and the distinction between create, modify, and delete.
Boundary 3 (What stops writes is the execution environment): In Kiro CLI and Kiro IDE, you can use the local command sandbox, which isolates commands run locally. It uses bubblewrap on Linux and Seatbelt on macOS. What it covers is the shell commands the agent runs and their child processes. The agent itself and its built-in file tools are outside the sandbox, and file reads and writes are controlled with Permissions. If you want OS-level isolation that includes writes through file tools, one option is to isolate the whole process, as BRIDGE does. In addition, Kiro Web runs agents in an isolated sandbox in the cloud, and Kiro Crew has an OS-level sandbox and signed audit logs.
Boundary 4 (Fix what was reviewed and what gets merged): Workflows provides a recipe (publish-pr) that creates a PR, addresses review comments, brings the PR to a mergeable state, and hands it to a human. If a human does the final merge, combining this with GitHub branch protection lets you align what was reviewed with what gets merged.
- Align the reviewed HEAD with the merged HEAD: "Dismiss stale pull request approvals when new commits are pushed" revokes approvals when new commits are added after approval. Together with this, "Require approval of the most recent reviewable push" requires someone other than the pusher to approve the latest update.
- Handle updates to the base: "Require branches to be up to date before merging" prevents merging until required checks pass with the latest base merged in. For repositories where merges frequently overlap, merge queue is also available.
You can also split roles within Kiro. In Workflows, each step runs in an independent session, and results pass between steps only through explicit handoffs. Since you can specify the agent and model for each step, you can have different models handle design, implementation, and review.
Do my reasons for building my own still hold?
Let me check the three reasons from Section 1 against Kiro's built-in features as of October 2026.
| Reason for building my own | In Kiro as of October 2026 | Need to build your own |
|---|---|---|
| 1. Combine the strengths of different AIs and run them as a team | Workflows can assign different agents and models to the planning, implementation, and review steps. External tools and information are available by adding MCP servers to Kiro | Usually not needed. Needed if you want an AI other than Kiro as the planner and want to keep the apps, connectors, and conversation context already set up in that AI |
| 2. Delegate everything except what humans should see | Workflows' publish-pr takes a PR to a mergeable state and hands the final merge to a human |
Needed only if you want to delegate merging too. Not needed if humans approve merges |
| 3. Stop on unexpected changes | Permissions can restrict writable paths in advance. After-the-fact verification can be built in with Hooks or CI | Needed for the verification step if you want each request to declare its scope and verify create, modify, and delete separately. In most cases, up-front restrictions plus human PR review are enough |
In other words, as of October 2026, if you keep everything within Kiro, most of the three reasons can be satisfied with built-in features. On the other hand, if you choose to use an AI other than Kiro as the planner, to delegate merging, or to verify scope in detail per request, you need a system outside Kiro. BRIDGE is the setup you get when you choose all three.
If you want to start the same thing with Kiro
If you want to start working this way with Kiro, without an external system like BRIDGE, you first build it from Kiro's built-in features and then add what you need based on the lessons from operation.
| Boundary | What Kiro's features cover | What you add yourself (lessons from operation) |
|---|---|---|
| 1. Do not hand over credentials, and fix operations | Permissions, Custom Agents (no write access for the reviewer), Workflows' investigate (read-only investigation) |
Make investigation and confirmation possible through the read path alone |
| 2a. Decide the scope of changes up front | Permissions (path patterns for fs_write) |
— |
| 2b. Verify afterwards | Hooks' Stop trigger can be used as the place to plug it in | A step that compares the allowed scope with the diff. No PR for tasks without changes. Regular detection of PRs that are no longer needed |
| 3. Stop writes in the execution environment | Local command sandbox, Kiro Web's sandbox, Kiro Crew | Record the types and counts of results where a boundary stopped something, without secrets |
| 4. Fix what is reviewed and merged | Workflows' publish-pr, GitHub branch protection (dismissing approvals, approval of the latest push, keeping up with the base), merge queue |
Verify against the latest main. If AI review takes things all the way to merge, add to the merge conditions that the review input was complete and that the decision was recorded |
If you use an AI other than Kiro as the planner, you also need a system that does not give that AI credentials, fixes the operations and arguments it can request, and separates READ and WRITE. If you expose long-running work, it is also worth deciding up front whether it will be synchronous or asynchronous.
Summary
Combining AI agents can now be done with Kiro's built-in features. The hard part is not connecting them. It is deciding which judgments to leave to the AI, what the system guarantees, and under what conditions work moves to the next stage.
Here is how responsibilities were split in BRIDGE. The right-hand column lists what the BRIDGE system alone cannot guarantee and what has to be covered by the fixes from the lessons or by human checks.
| Judgment left to the AI | What the system guarantees | What that alone cannot guarantee |
|---|---|---|
| How to implement | Whether changes stay within the declared files | Whether changes within the scope are implemented correctly |
| What tests are needed | Whether build and tests passed in a disposable environment | Whether build and tests also pass against the latest main |
| Review result | Whether the HEAD of the PR being merged matches the HEAD at review time | Whether the review saw the whole diff, and whether main moved after the review |
| Whether to merge | Whether the post-merge main contains the commit | Whether a human agreed with that decision |
When designing boundaries, you need to think beyond the boundaries themselves: how the AI will behave outside them, and whether you can verify afterwards that they worked. If you start the same thing with Kiro, these two points are worth checking too.
BrightFlow's product is currently in development. I will announce the release on social media, so please take a look when it comes out.
Terms of use
The setup in this article is built only with features each service officially provides: on the Kiro side, the official Kiro CLI (headless mode and ACP), and on the chat side, the custom MCP connection feature.
The terms of use of each service regarding combining AI agents with external tools may be updated. If you try a similar setup, check the latest terms of use for Kiro, the AI chat you use, and GitHub.
Top comments (4)
The boundary that matters most here is the third one — expected changes proceed, unexpected ones stop. Most agent setups either gate everything (and grind to a halt) or gate nothing (and merge surprises). A month of running BRIDGE is the real signal though: did the unexpected-file stop ever fire on something legitimate and slow a real task down?
I would keep that stop even if it sometimes pauses a real task. The cost of a short halt is easier to live with than a change the agent was never meant to make. After each halt I add the legitimate path to the allowed list, so the next run can proceed without loosening the rule.
The halt-then-allowlist loop is the right shape — the rule never loosens, it just gets more precise, and each pause teaches the boundary something. A short halt on a real task is cheap insurance against a change nobody asked for. Does the allowlist ever get pruned, or does it only grow as the agent's legitimate paths get mapped out?
The reviewed-head check and the separate “merged but sync failed” state are both valuable. One boundary I’m curious about is the target branch: if main changes after review while the PR head stays the same, the resulting merge can contain a combination that was never tested together. Does BRIDGE rerun the relevant checks against the prospective merge result or require a fresh review when the base moves? Keeping the reviewed head fixed solves one race; the base can still change the behavior being released.