S3 Sentinel — an AI agent with bounded authority

S3 Sentinel is a proof of concept for assisting with S3 control-plane operations under deliberate limits on what the agent can do with the access it holds. The agent can genuinely perform operations; application logic decides which buckets a caller may manage, which tools exist at all, and which proposed changes stop for a human decision before executing.

My role: security architecture, design decisions, direction and review of AI-assisted implementation, AWS integration, live verification, and operator-interface design.

Architecture diagram of S3 Sentinel as built: the operator CLI, the agent loop in AWS Lambda with its gate and approval step, the S3 and DynamoDB stores, and the evidence path to Splunk.

From a local prototype to AWS

The first version was a local LangGraph prototype developed through my AI4Business Lab work. It explored role-based tool access, a gatekeeper node, human-approval breakpoints, checkpointed state, response sanitization, and audit tags. Roles came from application configuration, not statements in a prompt.

The AWS version expanded that exploration into bucket-level authorization, read-versus-mutate tool tiers, durable approval state, and cloud deployment. It used Lambda for the multi-turn agent, Amazon Bedrock Nova Lite for the model, DynamoDB-backed LangGraph persistence, and Terraform for infrastructure.

Checking authority before asking for approval

The gate evaluates two dimensions: the caller’s standing over the requested bucket and the tool’s permission tier. Access is denied by default. An allowed read can proceed; a permitted mutation pauses for an explicit human decision.

The order matters. Standing is checked before the mutation path, so an unauthorized caller does not learn that a bucket exists and is changeable simply by requesting a write. A regression test exercises that out-of-standing mutation case.

A model’s explanation that a change is safe does not grant permission. IAM administration, arbitrary AWS API calls, and shell execution are outside the agent’s intended scope. Approval and conversational agreement also remain different events: typing “approve” into the chat is not an authorization action.

Integrating the boundaries with AWS

A Bedrock quota restriction initially blocked live model testing. I split the deployment work into an infrastructure-only track that could be applied and torn down while the quota request was unresolved, rather than treating an infrastructure deployment as proof that the agent worked.

The telemetry path connected S3 to SNS, SQS, and Splunk. End-to-end testing exposed a message-envelope mismatch; adding the SNS envelope fixed the integration without bypassing Splunk’s signature verification. Reader IAM permissions were separately checked with simulate-principal-policy.

Making the controls usable

The initial propose/approve/deny CLI exposed the control model but was cumbersome to operate. A guided consult command and a multi-turn REPL made it easier to discuss a proposed change while retaining the same authorization path. Identity is resolved from configuration before the conversation, and approval remains a discrete event outside the model’s narrative.

Live use found problems that offline tests had missed: stale terminal state replayed earlier advice, Lambda packaging omitted a compiled dependency, and transcript formatting caused the model to imitate tool-call text instead of invoking a tool. Those integration defects received fixes and regression tests. Model-quality problems, including an incorrect mutation confirmation, remained explicitly deferred rather than being treated as solved by the plumbing changes.

Reviewing the AI-assisted development process

I used design records and own-words sign-off to separate decisions I could explain from implementation I delegated. When an autonomous run marked decisions as settled without my genuine sign-off, I rolled the work back while preserving the branch and revised the approval process. A lighter guideline replaced enforcement that had itself become cumbersome.

Implementation and deployment used Claude and Codex under a shared autonomy contract with explicit stop conditions. One deployment halted after infrastructure had applied successfully because raw output exposed an account identifier. The halt caught a containment failure; it did not mean output containment was fully solved.

A later PR-style review checked the built artifacts against the design and found documentation drift and incorrect commit references. Generated summaries were inputs to that review, not substitutes for it.

What was demonstrated

Four charter security scenarios were exercised live against Nova Lite on real AWS infrastructure. The project also recorded end-to-end telemetry delivery, IAM policy simulation, and regression-tested REPL changes exercised against the live backend.

This was a live-tested proof of concept, not a shipped product or proof of general agent security. Outstanding work included an infrastructure apply/destroy enforcement gap, output containment, and model-quality issues. The MVP’s human approval was single-operator approval, not independent four-eyes authorization.