Inspiration
Coding agents can fix bugs quickly, but giving one broad access to a repository creates a difficult security choice: how do you let it work without trusting every file request or every change it proposes? Current agent approvals are frequently too coarse. Allowing an agent to run tests, edit a directory, or run a command does not mean every possible use of that capability is safe. We built IntentLock for security, platform, and DevOps teams that want to use coding agents while keeping a human in control of their access and final changes.
What it does
IntentLock puts two checks between a coding agent and your repository.
1. Action authorization
- A developer describes a task for the agent. AWS Bedrock drafts a contract, which lists allowed tools, paths, approved checks, and call limits, and a human reviews and approves the contract.
- Every Kiro tool call goes through our MCP proxy. During the run, a deterministic policy checks each controlled Kiro tool request and records whether it should be allowed or denied based on the contract.
- A denied action from the agent is blocked and an allowed action moves to the next phase.
However, an allowed action can still have a harmful result in the long run. We added a feature, Impact Preview, to address this problem
2. Consequence verification (Impact Preview)
- When the agent proposes a patch, it applies the patch in a read-only, networkless Docker sandbox, measures the exact changes, and runs fixed approved tests (the real repository is untouched).
- The checks that cover the changed files are chosen automatically from an administrator-owned
catalogue (
auth-tests,payments-tests,typecheck). The agent never sees or supplies a command line. - A failing patch is blocked. A passing patch is shown as a diff for human review and is never applied automatically. The promoter applies only the exact approved patch after checking its hash and the repository’s base commit.
- The dashboard shows the mission, live agent activity, impact reports, human review, and an audit trail. Security Replay reconstructs recorded decisions so a reviewer can inspect what happened later.
How we built it
- Control plane: a FastAPI service that holds contracts, runs, and events, and a deterministic
policy engine covering eight Kiro tools (
list_files,read_file,search_code,propose_patch,run_approved_test,run_approved_command,request_permission,finish_task). - Agent integration: a stdio MCP server and supervisor that launch real Kiro CLI sessions and route every tool call through authorization.
- Impact Preview: a Docker sandbox plus an impact analyzer that applies the patch, selects checks from the catalogue and produces a report.
- Dashboard: a React/Vite app with a mission-to-outcome timeline, a diff review screen and the Security Replay view.
- AWS: Bedrock drafts contracts. DynamoDB stores contracts, runs, and events. A Lambda authorizer returns allow or deny and fails closed on any error. CloudWatch receives the authorization metrics. ## Challenges we ran into The hardest distinction was between permission to propose a patch and permission to apply its result. A patch can target an allowed file yet weaken authentication. We made those separate decisions visible: IntentLock authorizes the request, then Impact Preview checks the patch’s consequences.
We also had to keep agent behavior and the demo evidence honest. Kiro does not always choose the same sequence of tools, and a denial or passing test means only what its recorded evidence shows. We addressed this with explicit contract settings, trusted test IDs, clear reason codes, exact patch hashes, and a replayable audit trail.
Accomplishments that we're proud of
- A real browser-driven Kiro run in which an unsafe patch was blocked by Impact Preview, and a corrected patch was reviewed and promoted.
- Binding human review to the exact patch. The promoted artifact is the reviewed artifact, checked by digest and base commit, not a rerun of the agent.
- Security Replay, which reconstructs a run from persisted evidence and labels anything missing as unavailable instead of guessing.
- A deployed Lambda authorizer whose latency we measured (p95 about 154 ms in Lambda). We claim no other performance figures.
What we learned
Agent safety cannot rely on static instructions alone. It must not only decide whether an action is within the human-approved mission but also inspect what an authorized change actually does. An agent may misunderstand a task, encounter misleading content, or make a change with effects that were not obvious from its request. We learned to enforce boundaries as the agent works, inspect the results of its actions, and keep a human responsible for approving consequential changes. Tests and a sandbox provide useful evidence for supported repository changes, but a passing result does not prove a patch is safe in every production environment. That is why IntentLock keeps human review and exact-patch promotion in the workflow.
What's next for IntentLock
We want to move the verified local flow onto a production-ready deployment, including AgentCore Gateway integration, stronger identity and IAM controls, and persistent AWS-backed operation. We also want to extend IntentLock beyond coding agents to agents that use browsers, cloud services, or business tools. Each new integration would need controls suited to its actions and consequences, while keeping the same core approach: enforce a human-approved mission, inspect consequential actions before they take effect, and preserve an auditable record.
Built With
- amazon-web-services
- bedrock
- docker
- kiro
- lambda
- mcp
- node.js
- python
- react
- typescript