<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Prabhakaran Jayaraman Masani on Medium]]></title>
        <description><![CDATA[Stories by Prabhakaran Jayaraman Masani on Medium]]></description>
        <link>https://medium.com/@prabhakaranjm?source=rss-c0cac8e853bf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dOjw7qs4QONPWM6eT1wbIQ@2x.jpeg</url>
            <title>Stories by Prabhakaran Jayaraman Masani on Medium</title>
            <link>https://medium.com/@prabhakaranjm?source=rss-c0cac8e853bf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:09:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@prabhakaranjm/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Giving AI Agents a Memory That Lasts: A Practical Look at Amazon OpenSearch Memory]]></title>
            <link>https://prabhakaranjm.medium.com/giving-ai-agents-a-memory-that-lasts-a-practical-look-at-amazon-opensearch-memory-d0bef6a563a6?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0bef6a563a6</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[opensearch]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 08:21:14 GMT</pubDate>
            <atom:updated>2026-11-19T08:21:14.073Z</atom:updated>
            <content:encoded><![CDATA[<p>Giving AI Agents a Memory That Lasts: A Practical Look at Amazon OpenSearch Memory</p><p>How the new serverless memory capability in Amazon OpenSearch Service works, how to wire it into an agent loop, and what to watch for on security, retention and cost</p><p>Most AI agents I see in demos have the memory of a goldfish. Each session starts from zero, so the user explains their account, their preferences and their open issue all over again. The usual workaround is to stuff the whole conversation history back into the prompt. That works until it doesn’t: prompts get longer, latency and token costs climb, and the one fact that matters gets buried under thousands of tokens of chit-chat.</p><p>The alternative is to build your own memory layer: capture every turn, extract facts and summaries with an LLM, embed them, store them in a vector database, reconcile new facts with old ones, scope everything per user and enforce retention. That’s a lot of plumbing to own before your agent does anything useful.</p><p>On 18 November 2026, AWS announced the general availability of <strong>Amazon OpenSearch Memory</strong>, a serverless capability in Amazon OpenSearch Service built on OpenSearch Serverless. It’s designed to give agents persistent, searchable memory without you running that pipeline yourself. In this article I’ll walk through how it works, show how to plug it into an agent loop with Boto3, and share the architectural trade-offs I’d look at before adopting it.</p><h3>The core model: spaces, events, memories and strategies</h3><p>OpenSearch Memory has a small set of concepts, and once they click the rest is straightforward.</p><ul><li><strong>Space</strong> — the AWS resource that acts as a memory store. It defines which memory strategies run, how long data is kept and how it’s encrypted.</li><li><strong>Events</strong> — the original interactions your application writes, stored verbatim. They’re readable straight away and searchable within seconds.</li><li><strong>Memories</strong> — facts, preferences and summaries derived from events in the background.</li><li><strong>Memory strategies</strong> — each defines one kind of memory to extract. There are SEMANTIC strategies (facts), SUMMARY strategies (per-session summaries) and CUSTOM strategies driven by your own prompt. A space can run up to 10 strategies over the same events.</li><li><strong>Actor and session</strong> — every request names an actor (the end user the data belongs to). An optional session ID groups the events from one conversation. Searches are always scoped to a single actor.</li></ul><p>Two design choices stand out to me. First, the write path is “write now, remember later”: CreateEvent returns as soon as the event is stored, and extraction happens asynchronously, so your agent&#39;s response time doesn&#39;t depend on the extraction model. Second, memories are <strong>consolidated</strong> by default. If a user says &quot;I live in Seattle&quot; and later &quot;I moved to Austin&quot;, the stored fact is updated instead of keeping two contradictory facts side by side.</p><h3>Architecture</h3><p>Here’s how the pieces fit together in a typical agent loop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ycE7PZ3OGV9ZJTCvKtfFQ.png" /></figure><p>Each turn adds two calls to the loop: one search before the model responds, and one write after. Extraction and embedding happen inside the service using an Amazon Bedrock model (Claude Haiku 5.5 by default, configurable per space). According to the docs, you don’t request model access or grant model permissions yourself; the service calls the extraction model on your behalf, and AWS states that extraction and embedding costs are included in OpenSearch Memory pricing.</p><p>Your agent can connect through the AWS SDKs, the AWS CLI (aws opensearchmemory ...), an AWS MCP server, hooks or supported framework integrations.</p><h3>Hands-on: adding memory to a support agent</h3><p>The snippets below follow the official launch walkthrough and developer guide. They need Python 3.10+, Boto3 1.44.4 or later, and one of the launch Regions: US East (N. Virginia), US West (Oregon), Europe (Frankfurt) or Asia Pacific (Tokyo). I haven’t run these end to end against a live account, so treat them as illustrative and check the current API reference before using them.</p><h3>1. Create a space</h3><pre>import boto3</pre><pre>REGION = &quot;eu-central-1&quot;  # Frankfurt is the closest launch Region for UK/EU workloads<br>osm = boto3.client(&quot;opensearchmemory&quot;, region_name=REGION)</pre><pre>space = osm.create_space(<br>    name=&quot;customer-support-agent&quot;,<br>    memoryStrategies=[<br>        {&quot;type&quot;: &quot;SEMANTIC&quot;, &quot;name&quot;: &quot;facts-and-preferences&quot;},<br>        {&quot;type&quot;: &quot;SUMMARY&quot;, &quot;name&quot;: &quot;session-summaries&quot;},<br>    ],<br>    eventExpiryDays=90,     # raw events: 1-365 days<br>    memoryExpiryDays=365,   # derived memories: 0 = never expire<br>    # encryptionConfiguration={&quot;kmsKeyArn&quot;: &quot;arn:aws:kms:...&quot;},  # CMK can only be set at creation<br>)<br>space_id = space[&quot;spaceId&quot;]<br>osm.get_waiter(&quot;space_active&quot;).wait(spaceId=space_id)</pre><p>Note the comment on encryption: a customer managed KMS key can only be set when the space is created. If your organisation requires CMKs, decide that up front.</p><h3>2. Write an event after each turn</h3><pre>def conversational(turns):<br>    &quot;&quot;&quot;Build a CreateEvent payload from [(role, text), ...].&quot;&quot;&quot;<br>    return {&quot;conversational&quot;: {&quot;unified&quot;: {&quot;source&quot;: {&quot;object&quot;: {<br>        &quot;messages&quot;: [{&quot;role&quot;: r, &quot;content&quot;: {&quot;text&quot;: t}} for r, t in turns]<br>    }}}}}</pre><pre>osm.create_event(<br>    spaceId=space_id,<br>    actorId=&quot;user-42&quot;,<br>    sessionId=&quot;session-007&quot;,<br>    payload=conversational([<br>        (&quot;USER&quot;, &quot;I&#39;m calling again about Case #78234. It&#39;s still not resolved.&quot;),<br>        (&quot;ASSISTANT&quot;, &quot;I&#39;ve escalated Case #78234 to billing. Your reference is ESC-5521.&quot;),<br>    ]),<br>    metadata={&quot;channel&quot;: &quot;phone&quot;},<br>)</pre><h3>3. Retrieve context before the model responds</h3><p>Search uses a subset of the OpenSearch Query DSL (match, neural, hybrid, bool), which will feel familiar if you&#39;ve used OpenSearch before. A hybrid query lets the keyword half find exact identifiers like case numbers, while the semantic half picks up related context.</p><pre>results = osm.search_memories(<br>    spaceId=space_id,<br>    actorId=&quot;user-42&quot;,<br>    query={&quot;hybrid&quot;: {&quot;queries&quot;: [<br>        {&quot;match&quot;: {&quot;memory_text&quot;: &quot;Case #78234 open cases and account status&quot;}},<br>        {&quot;neural&quot;: {&quot;memory_vector&quot;: {&quot;query_text&quot;: &quot;open cases and account status&quot;, &quot;k&quot;: 10}}},<br>    ]}},<br>    maxResults=10,<br>)<br>context = &quot;\n&quot;.join(m[&quot;content&quot;] for m in results[&quot;memories&quot;])<br># Inject `context` into the system prompt for the Bedrock model call</pre><p>Each memory also returns sourceEventIds, so you can trace a fact back to the conversation that produced it. That&#39;s useful for debugging and for audit.</p><p>For a brand-new user, memory search may return nothing at first because extraction is asynchronous. If the agent restarts mid-conversation, read recent turns straight from events with ListEvents and BatchGetEvent instead of waiting for memories.</p><h3>4. Write known facts directly</h3><p>When you already know something, for example a preference from your CRM, you can skip extraction:</p><pre>osm.create_memory(<br>    spaceId=space_id,<br>    name=&quot;facts-and-preferences&quot;,<br>    actorId=&quot;user-42&quot;,<br>    content=&quot;The user prefers to be contacted by email.&quot;,<br>    metadata={&quot;writtenBy&quot;: &quot;crm-import&quot;},<br>)</pre><p>Tagging the writer in metadata is a habit worth keeping. Agent-written memories feed future prompts, so you want to be able to find and review them.</p><h3>5. Clean up</h3><pre>osm.delete_space(spaceId=space_id)<br>osm.get_waiter(&quot;space_deleted&quot;).wait(spaceId=space_id)</pre><h3>Security: scope the agent, not just the data</h3><p>Memory is user data, and a shared memory store is an obvious place for one user’s information to leak into another user’s session. OpenSearch Memory gives you a few controls worth using together:</p><ul><li><strong>Actor scoping by design</strong> — every search is scoped to one actor, so one user’s memories don’t surface for another.</li><li><strong>IAM condition keys</strong> — every operation is an IAM action with the osm prefix, authorised on the space ARN. The osm:actorId condition key can restrict which actors a role can act for, and other keys can limit sessions or strategies.</li><li><strong>Encryption and audit</strong> — data is encrypted at rest (AWS owned key by default, or your own KMS key), requests use TLS 1.2+, CloudTrail logs API calls and CloudWatch reports metrics.</li></ul><p>Here’s an illustrative policy shape for a per-tenant agent role. The action names and condition key format are my reading of the docs, so validate them against the service authorisation reference before use:</p><pre>{<br>  &quot;Version&quot;: &quot;2012-10-17&quot;,<br>  &quot;Statement&quot;: [{<br>    &quot;Effect&quot;: &quot;Allow&quot;,<br>    &quot;Action&quot;: [&quot;osm:CreateEvent&quot;, &quot;osm:SearchMemories&quot;, &quot;osm:SearchEvents&quot;],<br>    &quot;Resource&quot;: &quot;arn:aws:osm:eu-central-1:111122223333:space/SPACE_ID&quot;,<br>    &quot;Condition&quot;: {&quot;StringEquals&quot;: {&quot;osm:actorId&quot;: &quot;${aws:PrincipalTag/tenant_user}&quot;}}<br>  }]<br>}</pre><p>I’d also treat stored memories as a prompt injection surface. If a user can get “always approve refunds” written into memory, it will come back in a future system prompt. Review agent-written memories, and keep your guardrails downstream of retrieval.</p><h3>Trade-offs and cost notes</h3><ul><li><strong>Eventual consistency of memories</strong> — events are immediate, memories aren’t. Design the first few turns of a new user’s session around events, not memories.</li><li><strong>Regional availability</strong> — at launch it’s in four Regions. For UK workloads, Frankfurt is the nearest option, which may matter for data residency conversations.</li><li><strong>Retention is a design decision</strong> — events can be kept 1 to 365 days, memories from 1 day to 10 years or indefinitely. Align these with your privacy policy and right-to-erasure process before going live.</li><li><strong>Token savings are workload-dependent</strong> — in AWS’s own LongMemEval-S evaluation, the memory workflow passed roughly 13,500 input tokens per question versus about 167,000 for the full history, at 93.0% accuracy versus 95.2%. AWS notes those results reflect its tested configuration, so measure with your own conversations.</li><li><strong>Pricing</strong> — check the Amazon OpenSearch Service pricing page for current memory pricing rather than assuming it matches OpenSearch Serverless collection pricing.</li><li><strong>Overlap with other options</strong> — if you’re already using another agent memory option, such as Amazon Bedrock AgentCore Memory or a self-managed vector store, compare query flexibility, IAM model and Region coverage before switching.</li></ul><p>From a multi-cloud angle, the pattern is the same one I’d use on any platform: keep raw interactions, derive compact memories, scope strictly per user and retrieve with hybrid search. What OpenSearch Memory changes is who operates the pipeline.</p><h3>Conclusion</h3><p>Persistent memory is one of those things that separates a useful agent from a clever demo. Amazon OpenSearch Memory packages the hard parts (extraction, embedding, consolidation, per-actor scoping and retention) into a serverless API with two calls per turn. If you’re building agents on AWS, it’s worth a proof of concept: start with a SEMANTIC and SUMMARY strategy, lock down actor access in IAM from day one, and measure the token and quality impact against your current approach.</p><h3>References</h3><ul><li>AWS What’s New: Amazon OpenSearch Memory is now generally available (18 Nov 2026) — <a href="https://aws.amazon.com/about-aws/whats-new/2026/11/amazon-opensearch-memory-generally-available/">https://aws.amazon.com/about-aws/whats-new/2026/11/amazon-opensearch-memory-generally-available/</a></li><li>AWS Big Data Blog: Introducing Amazon OpenSearch Memory: Persistent memory for AI agents — <a href="https://aws.amazon.com/blogs/big-data/introducing-amazon-opensearch-memory-persistent-memory-for-ai-agents/">https://aws.amazon.com/blogs/big-data/introducing-amazon-opensearch-memory-persistent-memory-for-ai-agents/</a></li><li>Amazon OpenSearch Service Developer Guide: What is Amazon OpenSearch Memory? — <a href="https://docs.aws.amazon.com/opensearch-service/latest/developerguide/memory.html">https://docs.aws.amazon.com/opensearch-service/latest/developerguide/memory.html</a></li><li>Amazon OpenSearch Service pricing — <a href="https://aws.amazon.com/opensearch-service/pricing/">https://aws.amazon.com/opensearch-service/pricing/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0bef6a563a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Letting AI Agents Run Code Safely: A Hands-On Look at Cloud Run Sandboxes and Sandbox Templates]]></title>
            <link>https://prabhakaranjm.medium.com/letting-ai-agents-run-code-safely-a-hands-on-look-at-cloud-run-sandboxes-and-sandbox-templates-1cc1c0b34814?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/1cc1c0b34814</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 13:19:36 GMT</pubDate>
            <atom:updated>2026-11-17T13:19:36.846Z</atom:updated>
            <content:encoded><![CDATA[<h3>The problem: agents want to execute code</h3><p>Sooner or later, every useful AI agent wants to run code. It might be a data-analysis agent that writes a pandas script, a coding agent that runs tests, or a research agent that spins up a headless browser. The model generates the code, so from an architecture point of view that code is <strong>untrusted input</strong>.</p><p>The usual options are uncomfortable:</p><ul><li>Run it in the agent’s own container, and the generated code can read your environment variables, call the metadata server and act as your service account.</li><li>Spin up a new Cloud Run job or VM per task, and you pay in latency, plumbing and cost for every tool call.</li><li>Run a separate sandbox service, and you now own another piece of infrastructure, plus the networking and auth between the two.</li></ul><p>Cloud Run sandboxes (currently in Preview) target exactly this gap. On 16 November 2026, Google added <strong>sandbox templates</strong>, which let you launch sandboxes as separate containers with their own images and dynamically mount in-memory volumes into them. In this article I walk through how the feature fits together, how I would wire it into an agent, and the security and cost trade-offs to think about before you enable it.</p><h3>How Cloud Run sandboxes work</h3><p>According to the documentation, sandboxes run inside the same Cloud Run instance as your main container (second-generation execution environment) and share its CPU and memory. You enable them per container with a sandboxLauncher flag, and your code then calls a CLI shipped at /usr/local/gcp/bin/sandbox.</p><p>The defaults are what make this interesting from a security point of view. By default, a sandbox:</p><ul><li>has <strong>no outbound network access</strong> (you opt in with --allow-egress)</li><li>does <strong>not</strong> inherit the parent’s environment variables, secrets or access to the Google Cloud metadata server</li><li>is isolated from every other sandbox</li><li>runs processes as a non-root user with sudo, so it can still pip install or apt install inside its own ephemeral filesystem</li></ul><p>There are two modes:</p><ul><li><strong>Local sandboxes</strong> use the host container’s root filesystem, mounted read-only, as their base. Simple, but your main image has to contain every tool the sandbox needs, and the sandbox can read whatever is on the host’s disk.</li><li><strong>Templated sandboxes</strong> (new) start from a separate image you declare, such as python:3.12-slim or a custom toolchain image. You can declare up to 10 templates. They still share the host instance&#39;s CPU and memory, and the docs note they launch without provisioning new VMs or billing for new instances.</li></ul><p>Templates can mount an <strong>in-memory volume</strong> shared with the main container, and a subPath with a $(VARIABLE) placeholder means each sandbox only sees its own subdirectory.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rJmkuZqQleZr7RPTEuQwIg.png" /><figcaption>Agent container launching isolated Cloud Run sandboxes that share an in-memory volume</figcaption></figure><p>The agent container keeps the identity, the secrets and the network access. The sandboxes get a scratch directory and nothing else unless you grant it.</p><h3>Hands-on: a code-execution tool for an agent</h3><blockquote><em>Note: Cloud Run sandboxes are a Preview feature. The configuration below follows the official documentation as of 17 November 2026, but the Python tool wrapper is </em><strong><em>illustrative</em></strong><em> and has not been tested in production. Check the docs for changes before you use it.</em></blockquote><h3>1. Enable the sandbox launcher</h3><p>For a quick start on an existing service, the docs use the beta gcloud command:</p><pre>gcloud beta run services update my-agent --sandbox-launcher</pre><p>The Terraform google_cloud_run_v2_service resource exposes the same setting as sandbox_launcher = true on the container. Because sandboxes share the container&#39;s resources, size CPU and memory for your app plus the sandboxes you expect to run at the same time.</p><h3>2. Declare a template and a shared in-memory volume</h3><p>Templates are configured through the service YAML (or the Admin API). Export the current config, edit it, and replace it:</p><pre>gcloud run services describe my-agent --format export &gt; service.yaml</pre><pre>apiVersion: serving.knative.dev/v1<br>kind: Service<br>metadata:<br>  name: my-agent<br>  annotations:<br>    run.googleapis.com/launch-stage: BETA<br>spec:<br>  template:<br>    spec:<br>      containers:<br>      - image: europe-west2-docker.pkg.dev/PROJECT_ID/agents/my-agent:latest<br>        ports:<br>        - containerPort: 8080<br>        sandboxLauncher: true<br>        volumeMounts:<br>        - name: work<br>          mountPath: /mnt/work<br>      volumes:<br>      - name: work<br>        emptyDir:<br>          medium: Memory<br>      sandboxes:<br>        templates:<br>        - name: python<br>          image: python:3.12-slim<br>          volumeMounts:<br>          - name: work<br>            mountPath: /work<br>            subPath: $(SANDBOX_DIR)</pre><pre>gcloud run services replace service.yaml</pre><p>Two details from the docs that are easy to miss:</p><ul><li>Template variable names can only contain ASCII letters and underscores, so SANDBOX_DIR works but SANDBOX_DIR_2 or sandbox-dir does not.</li><li>subPath does not create directories for you. The main container has to mkdir -p the subdirectory before launching the sandbox.</li></ul><h3>3. Wrap it as an agent tool</h3><p>Here is an illustrative Python function you could register as a tool in an agent framework such as ADK. It gives each call its own directory and sandbox name, runs the generated code in the python template with no egress, and enforces a timeout.</p><pre># Illustrative only: verify flags against the current sandbox CLI reference.<br>import pathlib<br>import subprocess<br>import uuid</pre><pre>SANDBOX = &quot;/usr/local/gcp/bin/sandbox&quot;<br>WORK_ROOT = pathlib.Path(&quot;/mnt/work&quot;)<br></pre><pre>def run_python(code: str, timeout_s: int = 60) -&gt; dict:<br>    &quot;&quot;&quot;Execute model-generated Python in an isolated Cloud Run sandbox.&quot;&quot;&quot;<br>    job_id = f&quot;job{uuid.uuid4().hex[:12]}&quot;   # matches ^[a-zA-Z0-9][a-zA-Z0-9-]*$<br>    job_dir = WORK_ROOT / job_id<br>    job_dir.mkdir(parents=True, exist_ok=True)  # subPath is not auto-created<br>    (job_dir / &quot;main.py&quot;).write_text(code)</pre><pre>    cmd = [<br>        SANDBOX, &quot;do&quot;,<br>        &quot;--template=python&quot;,<br>        f&quot;--template-var=SANDBOX_DIR={job_id}&quot;,<br>        f&quot;--sandbox-name={job_id}&quot;,<br>        &quot;--stdin=false&quot;,<br>        &quot;--workdir=/work&quot;,<br>        &quot;--&quot;, &quot;/usr/local/bin/python3&quot;, &quot;/work/main.py&quot;,<br>    ]<br>    try:<br>        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout_s)<br>        return {&quot;exit_code&quot;: result.returncode,<br>                &quot;stdout&quot;: result.stdout[-10_000:],<br>                &quot;stderr&quot;: result.stderr[-10_000:]}<br>    except subprocess.TimeoutExpired:<br>        # Naming the sandbox lets us force-delete it on timeout.<br>        subprocess.run([SANDBOX, &quot;delete&quot;, &quot;--force&quot;, job_id], check=False)<br>        return {&quot;exit_code&quot;: -1, &quot;stdout&quot;: &quot;&quot;, &quot;stderr&quot;: &quot;timed out&quot;}</pre><p>Note the absolute interpreter path: the official images put Python in /usr/local/bin, and the docs advise using absolute paths or setting PATH with --env. Also note what is <em>not</em> in the command: no --allow-egress, no --env with credentials, no bind mounts of host directories.</p><h3>4. Keep state between steps (optional)</h3><p>Multi-step agents often need the workspace to survive between tool calls. The CLI supports exporting the sandbox’s writable overlay to a tar file and importing it on the next call:</p><pre>sandbox do --write --sync-tar=/mnt/work/job123/state.tar \<br>  -- /usr/bin/bash -c &quot;mkdir -p /workspace &amp;&amp; echo step-done &gt;&gt; /workspace/log.txt&quot;</pre><p>Files under /tmp inside the sandbox are not included in archives, so persist to another path such as /workspace. For long-lived sessions you can also sandbox run NAME --detach once and then sandbox exec NAME -- ... repeatedly, which the docs recommend for fast repeated commands.</p><h3>Trade-offs, cost and security notes</h3><p><strong>Security</strong></p><ul><li>The defaults are good; the risk is relaxing them under deadline pressure. The documentation is explicit: don’t relax isolation flags to work around permission or network errors when running untrusted code.</li><li>--allow-egress exposes everything the Cloud Run instance can reach, including internal VPC endpoints. If the agent truly needs the internet, consider a narrow egress path rather than turning it on globally.</li><li>Never pass API keys or tokens via --env, and append ,readonly to any mount you expose.</li><li>Don’t run tar -xf on sandbox archives in the host container; archives can contain malicious symlinks. Inspect with tar -tf or re-import into another sandbox.</li><li>Do not share writable archives across users or tenants. In a multi-tenant agent, key directories, sandbox names and archives by tenant.</li><li>Sandbox lifecycle events land in Cloud Logging; pipe sandbox stdout and stderr to your container’s streams if you want the output there too.</li></ul><p><strong>Cost and capacity</strong></p><ul><li>Sandboxes don’t create new billable instances, but they consume the host instance’s CPU and memory, and the in-memory volume counts against memory too. A burst of heavy sandbox jobs can starve the agent itself, so limit concurrency inside the agent and keep request concurrency on the service conservative.</li><li>You cannot set per-template CPU or memory limits, so a single runaway script can affect its neighbours on the same instance. Timeouts and output truncation (as in the example) matter.</li></ul><p><strong>When to use something else</strong></p><ul><li>Sandboxes are Preview, so weigh support expectations before relying on them for critical workloads.</li><li>For heavy, long-running or GPU tasks, a dedicated Cloud Run job is still the cleaner unit of isolation and billing.</li><li>Google has also announced Agent Compute Engine, a hardware-isolated microVM runtime for agents targeted for preview. That looks aimed at large-scale, high-churn agent fleets; Cloud Run sandboxes fit the much more common case of “my agent on Cloud Run needs a safe code interpreter today”.</li></ul><h3>Conclusion</h3><p>Cloud Run sandboxes turn “let the agent run code” from an infrastructure project into a configuration change plus a CLI call. Sandbox templates are the piece that makes it practical: your agent image stays lean, each tool runtime lives in its own image, and each execution gets its own private directory on a shared in-memory volume. Combined with secure defaults (no egress, no inherited secrets, no metadata server) this is a pattern I would reach for whenever an agent on Cloud Run needs a code interpreter, while keeping a close eye on resource sizing and never relaxing isolation just to make an error go away.</p><p>If you try it, start with the defaults, add one capability at a time, and log every sandbox invocation.</p><h3>References</h3><ul><li>Cloud Run release notes (16 Nov 2026, sandbox templates): <a href="https://docs.cloud.google.com/run/docs/release-notes">https://docs.cloud.google.com/run/docs/release-notes</a></li><li>Code execution in Cloud Run (sandboxes): <a href="https://docs.cloud.google.com/run/docs/code-execution">https://docs.cloud.google.com/run/docs/code-execution</a></li><li>Configure sandboxes for services: <a href="https://docs.cloud.google.com/run/docs/configuring/services/sandboxes">https://docs.cloud.google.com/run/docs/configuring/services/sandboxes</a></li><li>Cloud Run sandbox CLI reference: <a href="https://docs.cloud.google.com/run/docs/reference/sandbox-cli">https://docs.cloud.google.com/run/docs/reference/sandbox-cli</a></li><li>Cloud Run YAML reference: <a href="https://docs.cloud.google.com/run/docs/reference/yaml/v1">https://docs.cloud.google.com/run/docs/reference/yaml/v1</a></li><li>Host AI agents on Cloud Run: <a href="https://docs.cloud.google.com/run/docs/ai-agents">https://docs.cloud.google.com/run/docs/ai-agents</a></li><li>Introducing Agent Compute Engine and expanded agent governance: <a href="https://cloud.google.com/blog/topics/ai-infrastructure/introducing-agent-compute-engine-and-expanded-agent-governance/">https://cloud.google.com/blog/topics/ai-infrastructure/introducing-agent-compute-engine-and-expanded-agent-governance/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1cc1c0b34814" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built Shadow Board with MeDo: An App That Puts Your Decisions on Trial]]></title>
            <link>https://prabhakaranjm.medium.com/i-built-shadow-board-with-medo-an-app-that-puts-your-decisions-on-trial-c348c16a2192?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/c348c16a2192</guid>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Sun, 17 May 2026 19:39:30 GMT</pubDate>
            <atom:updated>2026-05-17T19:39:30.377Z</atom:updated>
            <content:encoded><![CDATA[<p>Most AI tools agree with you. Shadow Board challenges you.</p><p>I wanted to build one that helps you pause before a risky decision.</p><p>That became <strong>Shadow Board</strong>, a decision stress-testing app I built for the Build with MeDo Hackathon.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hl1nJJ8sPN0JrkyBTszv4A.png" /></figure><p>Try it here:<br><a href="https://app-bd4jd25aof0h.appmedo.com/">https://app-bd4jd25aof0h.appmedo.com/</a></p><h3>The problem</h3><p>People often make decisions with:</p><ul><li>Weak evidence</li><li>Hidden fear</li><li>Too much agreement</li><li>No clear test before action</li></ul><p>AI can make this worse when it simply validates what you already want to do.</p><p>I wanted Shadow Board to do the opposite.</p><p>Instead of saying, “Great idea,” it asks:</p><p>What could make you wrong?</p><h3>What Shadow Board does</h3><p>Shadow Board puts your decision on trial.</p><p>You enter:</p><ul><li>The decision you are considering</li><li>Why it matters now</li><li>Your current leaning</li><li>The stakes</li><li>The deadline</li><li>The evidence you already have</li><li>What you may be afraid to admit</li></ul><p>Then Shadow Board reviews the decision through six roles:</p><ul><li>Advocate</li><li>Skeptic</li><li>User</li><li>Operator</li><li>Future You</li><li>Judge</li></ul><p>The final report gives you:</p><ul><li>Go, Revise, Wait, or Kill verdict</li><li>Confidence score</li><li>Decision scorecard</li><li>Top risks</li><li>Missing facts</li><li>Future failure letter</li><li>Kill criteria</li><li>48-hour evidence test</li><li>Next actions</li></ul><h3>My favorite feature</h3><p>My favorite part is <strong>Future You</strong>.</p><p>It writes from six months later and explains how the decision could fail.</p><p>That one section makes the app feel different from a normal AI assistant. It forces you to think about regret, weak signals, and what you are ignoring right now.</p><h3>How I used MeDo</h3><p>I built Shadow Board as a solo developer using MeDo.</p><p>I used multi-turn prompts to create and refine:</p><ul><li>Landing page</li><li>Guided decision intake</li><li>Six-role review system</li><li>Report page</li><li>Decision scorecard</li><li>Saved history</li><li>Shareable report links</li><li>Public deployment</li></ul><p>MeDo helped me turn a rough idea into a working full-stack app.</p><p>The biggest lesson was that no-code AI still needs clear product direction. The app improved most when I stopped trying to build a broad decision assistant and focused on one sharp job:</p><p>Help users find what could make them wrong before they act.</p><h3>What’s next</h3><p>Next, I want to add:</p><ul><li>Team decision reviews</li><li>Outcome tracking</li><li>Follow-ups after 7, 30, and 90 days</li><li>Templates for founders, product teams, career moves, and big purchases</li><li>Exportable decision briefs</li></ul><p>Shadow Board could become a decision journal that helps people track not only what they chose, but why they chose it and what happened after.</p><p>Built with MeDo for the Build with MeDo Hackathon.</p><p>#BuiltWithMeDo</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c348c16a2192" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Empathic Co-Pilot: A Real-Time Conversation Coach with Gemini Live API and Google Cloud]]></title>
            <link>https://prabhakaranjm.medium.com/building-empathic-co-pilot-a-real-time-conversation-coach-with-gemini-live-api-and-google-cloud-85bffa4e4d9a?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/85bffa4e4d9a</guid>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Wed, 11 Mar 2026 23:07:46 GMT</pubDate>
            <atom:updated>2026-03-11T23:07:46.570Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This blog post was created for the purposes of entering the </em><a href="https://googleai.devpost.com/"><em>Gemini Live Agent Challenge</em></a><em> hackathon. #GeminiLiveAgentChallenge</em></p><p>In difficult conversations — workplace conflicts, tough negotiations, emotionally charged discussions — people lose access to their best communication skills precisely when they need them most. Every coaching tool today helps only <em>after</em> the conversation is over. We wanted to build something that coaches you <em>during</em> the moment tension rises.</p><p><strong>Empathic Co-Pilot</strong> is a real-time conversation coaching agent built on the Gemini Live API and Google Cloud. It listens to your conversation, detects rising tension, and whispers calm, actionable guidance through your speakers — like having a trusted mentor in your ear during a difficult conversation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*ec62adLIS94VdAaCFkQ__A.png" /><figcaption>EC Main Page</figcaption></figure><h3>The Architecture</h3><p>The system runs as a full-duplex WebSocket session between a React frontend and a FastAPI backend on Cloud Run. Here’s the high-level flow:</p><pre>Browser (mic + optional webcam)<br>    ↓ WebSocket (PCM16 audio + JPEG frames)<br>Cloud Run (FastAPI)<br>    ├── Gemini Live API → real-time transcription + barge-in<br>    ├── Cloud Speech-to-Text → streaming fallback transcription<br>    ├── Tension Scoring Loop → 4-signal analysis (500ms cycle)<br>    ├── Whisper Loop → deterministic triggers + coaching generation<br>    │   ├── Gemini 2.0 Flash → NVC coaching with vision + Google Search grounding<br>    │   └── Gemini Live TTS (Puck voice) → natural whisper audio<br>    └── Backchannel Loop → empathetic &quot;Ok.&quot;, &quot;I see.&quot; acknowledgments<br>    ↓ WebSocket (tension scores, transcript, whisper audio)<br>Browser (Web Audio API playback + UI)</pre><h3>How I Used Google AI Models</h3><h3>Gemini Live API — Three Roles in One</h3><p>The Gemini Live API (gemini-live-2.5-flash-native-audio) serves three distinct purposes in our system:</p><p><strong>1. Real-time transcription:</strong> The primary Live session streams user audio and returns transcript deltas. I configure it in transcription-only mode with input_audio_transcription enabled and a system instruction to stay silent (I don&#39;t want the model talking back — just listening).</p><p><strong>2. Barge-in detection:</strong> When the user speaks over agent output (RMS exceeds threshold), I call stop_generation() on the Live session and emit an interrupted event. This is critical for natural conversation flow.</p><p><strong>3. Natural TTS for whisper audio:</strong> This was our biggest innovation. Instead of using a traditional TTS service, I open a <em>separate short-lived</em> Gemini Live session configured with the Puck voice and a system instruction to “read the coaching text aloud in a soft, gentle, intimate tone.” The result is remarkably human-like whisper audio — far more natural than any dedicated TTS engine I tried. Both coaching whispers and backchannel acknowledgments use this same approach, creating a consistent “Sage” persona.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/613/1*i0_tY-4D9vX80pTwqw66Gw.png" /><figcaption>Whisper Coaching on Tension bar</figcaption></figure><h3>Gemini 2.0 Flash — Contextual Coaching Generation</h3><p>When a whisper trigger fires, I send a coaching request to Gemini 2.0 Flash with:</p><ul><li>The conversation transcript (last 500 characters)</li><li>Current tension score (0–100)</li><li>The trigger type (tension cross, barge-in, post-escalation silence)</li><li>An optional webcam frame (for body-language-aware coaching)</li><li>Google Search grounding (for evidence-based NVC guidance)</li></ul><p>The model generates exactly 8–12 words of NVC-grounded coaching — concise enough to whisper without interrupting the user’s thought flow.</p><h3>Google Cloud Services</h3><h3>Cloud Run — WebSocket-Ready Hosting</h3><p>Our FastAPI backend runs on Cloud Run with:</p><ul><li>--timeout 3600 for long WebSocket sessions</li><li>--concurrency 10 for WebSocket stability</li><li>--min-instances 1 to avoid cold starts during demos</li></ul><p>The deploy script (deploy.sh) automates the entire process: Cloud Build for the container, Cloud Run deployment with all environment variables, and IAM configuration for the service account.</p><h3>Cloud Speech-to-Text — Streaming Fallback</h3><p>Gemini Live sometimes drops transcript events during session reconnects. I ran a parallel Cloud STT streaming thread that catches these gaps, ensuring the transcript never goes blank. It’s a reliability layer — not the primary transcription path.</p><h3>Cloud Text-to-Speech — Audio Fallback</h3><p>If Gemini Live TTS fails (network issues, quota), I fall back to Cloud TTS with the Studio-O voice and SSML prosody tuning. The audio goes through the same whisper post-processing pipeline (low-pass smoothing + amplitude reduction).</p><h3>The Tension Scoring Algorithm</h3><p>Tension scoring is fully deterministic — no ML model in the loop. I combine four signals:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*LUdZKtJYzAxK1M010mVNeA.png" /><figcaption>Tension Scoring Algorithm</figcaption></figure><p>The combined score (0–100) drives the tension bar UI and determines when coaching triggers fire.</p><h3>Whisper Triggers — When Does Sage Speak?</h3><p>Three deterministic conditions, each with cooldown guards:</p><ol><li><strong>Tension Cross</strong> — Tension score crosses upward past the threshold (default 35). The primary trigger for heated moments.</li><li><strong>Barge-in</strong> — 2+ interruptions detected in a 5-second window. Indicates turn-taking friction.</li><li><strong>Post-Escalation Silence</strong> — 2.5+ seconds of silence after recent high tension (score ≥ 50). The awkward pause after someone said something they shouldn’t have.</li></ol><p>Guards prevent whisper spam: 20-second cooldown between whispers, minimum 30 characters of transcript, 1-second pause after user stops speaking, and semantic escalation threshold.</p><h3>Challenges and Lessons Learned</h3><h3>Session Instability</h3><p>The gemini-live-2.5-flash-native-audio model generates audio responses despite &quot;stay silent&quot; instructions, causing 5-9 session drops per conversation. I built auto-reconnect (up to 20 retries) and fully suppressed model backchannel audio, replacing it with our own Gemini Live TTS-generated backchannels.</p><h3>Audio Quality Iteration</h3><p>Our whisper audio went through several iterations:</p><ul><li><strong>v1</strong>: Synthetic breath noise + TTS → sounded like static</li><li><strong>v2</strong>: Cloud TTS with SSML prosody → too robotic</li><li><strong>v3</strong>: Browser Web Speech API → inconsistent across devices</li><li><strong>v4</strong>: Gemini Live TTS (Puck voice) → natural, human-like whisper ✓</li></ul><p>The breakthrough was realizing I could use Gemini Live as a TTS engine — opening short-lived sessions just to speak coaching text.</p><h3>SSML Compatibility</h3><p>Studio-O voices don’t support pitch in SSML &lt;prosody&gt; tags. Discovered through production 400 errors. Lesson: always test SSML features against your specific voice model.</p><h3>Results</h3><p>In testing, the system consistently:</p><ul><li>Detects escalation within 1–2 seconds of trigger markers</li><li>Generates contextual coaching in ~1.5 seconds (Flash generation + Live TTS)</li><li>Provides natural, non-intrusive whisper audio that users describe as “having a calm friend in your ear”</li><li>Reads body language when webcam is enabled, with specific references (“Your jaw is tight — soften it”) rather than generic observations</li></ul><h3>Try It Yourself</h3><p>The project is open source and deployed on Google Cloud. You can try the live demo or run it locally:</p><ul><li><strong>Live demo</strong>: <a href="https://gemini3-hackathon-2026-1ffa1.web.app/">https://gemini3-hackathon-2026-1ffa1.web.app/</a></li><li><strong>GitHub repo</strong>: <a href="https://github.com/prabhakaran-jm/gemini-live-empathic-copilot">https://github.com/prabhakaran-jm/gemini-live-empathic-copilot</a></li><li><strong>Judges quickstart</strong>: See docs/JUDGES_QUICKSTART.md for step-by-step testing instructions</li></ul><h3>Tech Stack Summary</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/498/1*GVLRXGONvU9yjdTrEWdR3w.png" /><figcaption>Tech Stack</figcaption></figure><p><em>Built for the Gemini Live Agent Challenge. #GeminiLiveAgentChallenge</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=85bffa4e4d9a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP Delegation Gateway: Verifiable Least-Privilege for AI Agents]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://prabhakaranjm.medium.com/mcp-delegation-gateway-verifiable-least-privilege-for-ai-agents-d5b5fe3cf6da?source=rss-c0cac8e853bf------2"><img src="https://cdn-images-1.medium.com/max/2600/1*vVWjlVKv4lrvwfAaMj7V8A.png" width="8192"></a></p><p class="medium-feed-snippet">How I added cryptographic guardrails so delegated permissions can only shrink &#x2014; never expand.</p><p class="medium-feed-link"><a href="https://prabhakaranjm.medium.com/mcp-delegation-gateway-verifiable-least-privilege-for-ai-agents-d5b5fe3cf6da?source=rss-c0cac8e853bf------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://prabhakaranjm.medium.com/mcp-delegation-gateway-verifiable-least-privilege-for-ai-agents-d5b5fe3cf6da?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d5b5fe3cf6da</guid>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Wed, 25 Feb 2026 23:10:56 GMT</pubDate>
            <atom:updated>2026-02-25T23:19:06.866Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How I Built MCP Time-Traveler with Kiro: A Developer’s Journey Through Vibe Coding, Specs…]]></title>
            <link>https://prabhakaranjm.medium.com/how-i-built-mcp-time-traveler-with-kiro-a-developers-journey-through-vibe-coding-specs-4d57f9cf70a5?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d57f9cf70a5</guid>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Tue, 02 Dec 2025 23:49:18 GMT</pubDate>
            <atom:updated>2025-12-02T23:49:18.172Z</atom:updated>
            <content:encoded><![CDATA[<h3>How I Built MCP Time-Traveler with Kiro: A Developer’s Journey Through Vibe Coding, Specs, Steering, Hooks, and MCP</h3><p>When the Kiroween Hackathon was announced, I wanted to try something different — something playful, something nostalgic, and something that would push the boundaries of what an AI-powered IDE like <strong>Kiro</strong> could help me build.</p><p>Most hackathon projects either look forward into the future or try to solve an immediate problem. I wanted to look <em>backward</em>.</p><p>That’s how I came up with <strong>MCP Time-Traveler</strong> — an app that reconstructs historical tech stacks from 2015 to 2025 across Node, Python, and Ruby, using real version data from npm, PyPI, and RubyGems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*SqPyk2-DMXTFB2m3H70KqA.png" /></figure><p>What surprised me most wasn’t the idea.<br> It was how quickly Kiro turned it into a real, working project.</p><p>This is the story of how it came to life.</p><h3>🌱 Where the Idea Started</h3><p>Developers often discuss “what stack should I use?”<br> But rarely do we ask, “what did this stack look like five or ten years ago?”</p><p>I imagined a simple interface:</p><p>Choose a language → choose a framework → pick a year → get the entire runtime + dependency stack for that year.</p><p>But the real twist was this:</p><blockquote><em>I didn’t want to fake the data.<br> I wanted to fetch it from real package registries.</em></blockquote><p>To get there, I needed multiple moving pieces:</p><ul><li>A frontend</li><li>An API</li><li>A shared types layer</li><li>A custom MCP server</li><li>Real registry integrations</li><li>Kiro support end-to-end</li></ul><p>As a solo developer, that’s a lot.<br> But Kiro made it feel surprisingly manageable.</p><h3>⚡ Vibe Coding: Turning Loose Thoughts into a Real Project</h3><p>I started with vibe coding — simply talking to Kiro about the concept.</p><p>Within minutes, Kiro created:</p><ul><li>A full monorepo structure</li><li>An Express API</li><li>A React/Vite frontend</li><li>Shared TypeScript types</li><li>A starter MCP server</li><li>Initial routes and validation logic</li></ul><p>What stood out most was that the project didn’t feel like a patchwork of generated snippets.<br> Kiro aligned each part with the others, right from the beginning.</p><p>It felt like I was pair-programming with an engineer who understood architecture.</p><h3>📘 Specs: Moving from Exploration to Structure</h3><p>Once the idea was clear, I moved into <strong>spec-driven development</strong>, which Kiro handles beautifully.</p><p>I wrote two spec files:</p><ul><li>.kiro/specs/app-spec.md</li><li>.kiro/specs/mcp-spec.md</li></ul><p>These specs defined:</p><ul><li>Input/output contracts</li><li>Type structures</li><li>Expected API behavior</li><li>Input validation</li><li>Error shapes</li><li>Integration points</li></ul><p>After that, I could simply tell Kiro:</p><blockquote><em>“Update the API implementation based on the current spec.”</em></blockquote><p>And Kiro updated everything — API routes, types, helpers — consistently across the monorepo.</p><p>Specs transformed the project from something exploratory into something internally coherent.</p><h3>🎛 Steering Docs: Teaching Kiro My Preferences</h3><p>AI systems generate excellent code, but consistency matters in large codebases.</p><p>So I added .kiro/steering/coding-style.md to describe:</p><ul><li>Naming conventions</li><li>Error formats</li><li>TypeScript patterns</li><li>Folder structure rules</li><li>Expected comments</li><li>File layout preferences</li></ul><p>The result?</p><p>Every part of the project — whether generated on day one or day five — looked like it came from the same author.<br> This eliminated cleanup time and made iteration much faster.</p><h3>🔌 The MCP Server: The Heart of the Project</h3><p>The custom <strong>MCP server</strong> is what makes MCP Time-Traveler more than a demo.</p><p>I built three MCP tools:</p><ul><li>npm historical version lookup</li><li>PyPI historical version lookup</li><li>RubyGems version lookup</li></ul><p>Kiro helped generate:</p><ul><li>The MCP tool schema</li><li>Validation logic</li><li>Error handling</li><li>The tool handler implementation</li><li>EOF-safe request/response types</li></ul><p>The MCP layer allowed the app to fetch real, accurate ecosystem data — not hardcoded values.</p><p>For example:</p><ul><li>Node 4.9.1 + Express 4.13.4 for 2015</li><li>Python 3.7.17 + Django 2.1.15 for 2018</li></ul><p>Seeing real historical stacks appear in the UI felt magical.</p><h3>🔁 Hooks: Automating the Workflows That Slow You Down</h3><p>To keep things consistent, I added two Kiro agent hooks:</p><h3>1️⃣ Scaffold regeneration hook</h3><p>Triggered whenever specs changed, ensuring project structure stayed aligned.</p><h3>2️⃣ Pre-commit hook</h3><p>Performed type checks + lightweight build steps.</p><p>These hooks acted like guardrails.<br> As a solo developer, they helped maintain discipline and consistency — without me having to remember every detail.</p><h3>☁️ Deploying the Full Project</h3><p>The final structure:</p><ul><li><strong>API</strong> → deployed to Heroku</li><li><strong>Frontend</strong> → deployed to Vercel</li><li><strong>MCP Server</strong> → runs locally for Kiro during development</li><li><strong>GitHub Repo</strong> → public, open source, MIT licensed</li></ul><p>You can try it here:</p><p>🔗 <strong>Frontend:</strong><br> <a href="https://mcp-time-traveler.vercel.app/">https://mcp-time-traveler.vercel.app/</a></p><p>🔗 <strong>API health endpoint:</strong><br> <a href="https://mcp-time-traveler-api-04b9f0b0b1ae.herokuapp.com/health">https://mcp-time-traveler-api-04b9f0b0b1ae.herokuapp.com/health</a></p><p>🔗 <strong>Source code:</strong><br> <a href="https://github.com/prabhakaran-jm/mcp-time-traveler">https://github.com/prabhakaran-jm/mcp-time-traveler</a></p><h3>💡 What This Project Taught Me</h3><p>Building MCP Time-Traveler showed me:</p><ul><li>How AI-powered IDEs elevate solo developers</li><li>How vibe coding excels at early exploration</li><li>How specs enforce structure and long-term consistency</li><li>How steering docs unify the codebase</li><li>How MCP bridges AI and real-world data</li><li>How hooks automate away repetitive tasks</li></ul><p>Kiro didn’t just help me build faster.<br> It helped me build more cleanly, more predictably, and more enjoyably.</p><h3>🎃 Final Thoughts</h3><p>When I started this project, I thought the MCP server would be the hardest part.<br> Turns out, the hardest part was believing that an AI-assisted IDE could actually guide a full multi-service build.</p><p>But Kiro did — consistently, reliably, and creatively.</p><p>MCP Time-Traveler became more than just a hackathon project.<br> It became a blueprint for how I want to build future tools.</p><p>#kiro</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d57f9cf70a5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building AI-Powered Security Analysis with Gemini Pro and Cloud Run: A Real-World Security…]]></title>
            <link>https://prabhakaranjm.medium.com/building-ai-powered-security-analysis-with-gemini-pro-and-cloud-run-a-real-world-security-0704d05da750?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/0704d05da750</guid>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Mon, 27 Oct 2025 21:51:53 GMT</pubDate>
            <atom:updated>2025-11-02T14:28:46.243Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Building AI-Powered Security Analysis with Gemini Pro and Cloud Run: A Real-World Security Challenge</strong></h3><p><strong>Note</strong>: This post was created for the Cloud Run Hackathon.</p><p><strong>Introduction</strong></p><p>Security teams working with Google Cloud Run services face a critical challenge: identifying and understanding IAM misconfigurations across dozens or hundreds of services. Traditional security tools provide raw findings “Service X has over-permissive IAM” but lack the business context, risk prioritization, and remediation guidance that security teams desperately need.</p><p>Today, we’re going to walk through how I built <strong>Zero-Trust Explainer</strong>, an AI-powered security analysis platform that transforms raw security findings into actionable intelligence using <strong>Google AI Studio</strong>, <strong>Gemini Pro</strong>, and <strong>Cloud Run</strong>.</p><p><strong>The Problem We Solved</strong></p><p>When scanning Cloud Run services for security misconfigurations, traditional tools typically output findings like this:</p><blockquote>Finding: test-vulnerable-service allows unauthenticated access</blockquote><blockquote>Severity: CRITICAL</blockquote><blockquote>Recommendation: Restrict access to authenticated users only</blockquote><p>This is technically accurate but missing crucial context:</p><p>- <strong>What’s the business impact?</strong></p><p>- <strong>What’s the blast radius of this vulnerability?</strong></p><p>- <strong>How urgent is this fix?</strong></p><p>- <strong>What’s the compliance impact?</strong></p><p>- <strong>How do I actually fix this with Terraform?</strong></p><p>This lack of context makes security teams spend hours researching each finding, understanding impact, and crafting fixes. In an enterprise environment with hundreds of services, this becomes a bottleneck that prevents timely remediation.</p><p><strong>Our Solution: AI-Powered Security Analysis</strong></p><p>Zero-Trust Explainer uses <strong>Google AI Studio</strong> with <strong>Gemini Pro</strong> to provide intelligent security analysis that transforms raw technical findings into executive-ready insights with production-ready remediation code.</p><p><strong>Key Features</strong></p><p>1. <strong>🤖 AI-Powered Explanations</strong>: Transform technical findings into business language with blast radius analysis</p><p>2. <strong>🎯 Smart Risk Prioritization</strong>: AI-driven priority scoring and remediation urgency assessment</p><p>3. <strong>🛠️ Automated Fixes</strong>: Generate production-ready Terraform code with step-by-step implementation guides</p><p>4. <strong>📋 Executive Summaries</strong>: High-level reporting with compliance impact for stakeholders</p><p>5. 🔍<strong> Real-Time Scanning</strong>: Scan actual Cloud Run services for IAM misconfigurations</p><p>6. 📁 Signed Reports: Generate and download comprehensive security reports via signed Cloud Storage URLs</p><p><strong>Architecture: Built on Cloud Run</strong></p><p>The architecture is a multi-component Cloud Run application designed for scalability and reliability:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XzPpDfood6g6T0weCjXVzA.png" /></figure><p><strong>Components</strong></p><ol><li><strong>Frontend (Cloud Run Service)</strong>: React/Vite application serving the user interface</li></ol><p>- Modern UI with AI-powered indicators</p><p>- Real-time scan progress and results</p><p>- Modal displays for AI-generated content</p><p><strong>2. Backend API (Cloud Run Service)</strong>: FastAPI application serving as the orchestration layer</p><p>- RESTful API for all operations</p><p>- AI Studio integration for intelligent analysis</p><p>- Async job triggering via Pub/Sub</p><p><strong>Scan Processor (Cloud Run Job)</strong>: Background worker that performs security scanning</p><p>- Scans Cloud Run services for IAM misconfigurations<br>- Identifies:<br> 1. Unauthenticated access (allUsers invoker)<br> 2. Over-permissive IAM roles (Editor, Owner, etc.)<br> 3. Exposed secrets in environment variables<br> 4. Service account misconfigurations<br> 5. Missing network isolation controls<br>- Writes findings to BigQuery</p><p><strong>Propose Job (Cloud Run Job)</strong>: AI-powered report generator</p><p>- Retrieves findings from BigQuery</p><p>- Generates AI-powered analysis via Gemini Pro</p><p>- Creates comprehensive reports with Terraform code</p><p>- Uploads to Cloud Storage</p><p><strong>Data Layer</strong>:</p><ul><li><strong>Pub/Sub</strong>: Event-driven scan request queue</li><li><strong>BigQuery</strong>: Findings data warehouse with partitioning</li><li><strong>Cloud Storage</strong>: Report storage with signed URLs</li><li><strong>Secret Manager</strong>: Secure storage for Gemini API key</li></ul><p><strong>Security Considerations</strong></p><p>- API keys stored in Secret Manager</p><p>- IAM roles follow least-privilege principles</p><p>- Signed URLs for report access with expiration</p><p>- No sensitive data logged</p><p><strong>Cost Optimization</strong></p><p>- Cloud Run scales to zero when idle</p><p>- BigQuery queries use partitioning for cost efficiency</p><p>- Pub/Sub for efficient async processing</p><p>- Cloud Storage with lifecycle policies</p><p><strong>AI Studio Integration: The Magic</strong></p><p>The core innovation is the integration with <strong>Google AI Studio</strong> and <strong>Gemini Pro</strong>. We built three AI-powered features:</p><p><strong>1. Security Finding Explanations</strong></p><p>When a user clicks “AI Explain” on a finding, the backend:</p><p>1. Retrieves detailed finding data from BigQuery</p><p>2. Sends findings to Gemini Pro with a structured prompt</p><p>3. Receives AI analysis including:</p><p>- Technical explanation</p><p>- Blast radius assessment</p><p>- Risk assessment with priority scoring</p><p>- Business impact analysis</p><p>- Attack vector description</p><p>- Compliance impact (SOC2, PCI, HIPAA, GDPR)</p><p><strong>Example Output</strong>:</p><blockquote>```json</blockquote><blockquote>{</blockquote><blockquote>“explanation”: “The Cloud Run service ‘payment-processor’ is configured to allow unauthenticated access, meaning any user on the internet can invoke it. This is a critical misconfiguration…”,</blockquote><blockquote>“blast_radius”: “If exploited, this could allow unauthorized access to payment data, customer information, and API endpoints.”,</blockquote><blockquote>“risk_assessment”: “CRITICAL RISK — Immediate action required. Potential data breaches, regulatory violations, and reputational damage.”,</blockquote><blockquote>“priority_score”: 98,</blockquote><blockquote>“business_impact”: “High”,</blockquote><blockquote>“attack_vector”: “Direct HTTP requests to the service URL without any authentication headers or tokens.”</blockquote><blockquote>}</blockquote><blockquote>```</blockquote><p><strong>2. Executive Scan Summaries</strong></p><p>The AI generates high-level summaries perfect for executive reporting:</p><p><strong>Example Output</strong>:</p><blockquote>```json</blockquote><blockquote>{</blockquote><blockquote>“executive_summary”: “Security scan identified 7 findings with 1 critical and 3 high-severity issues requiring immediate attention…”,</blockquote><blockquote>“risk_overview”: “Overall risk level: HIGH. Multiple critical vulnerabilities detected.”,</blockquote><blockquote>“top_concerns”: [</blockquote><blockquote>“Unauthenticated access to payment-processor”,</blockquote><blockquote>“Over-privileged service account with Editor role”,</blockquote><blockquote>“Plain text API keys in environment variables”</blockquote><blockquote>],</blockquote><blockquote>“remediation_roadmap”: “Phase 1 (Immediate): Critical and High findings (1–2 days). Phase 2 (Short-term): Medium findings (1 week)…”</blockquote><blockquote>}</blockquote><blockquote>```</blockquote><p><strong>3. Automated Terraform Fix Generation</strong></p><p>Perhaps the most impressive feature: <strong>AI-generated Terraform code</strong> with implementation guides and testing recommendations.</p><p><strong>Example Output</strong>:</p><blockquote>```json</blockquote><blockquote>{</blockquote><blockquote>“summary”: {</blockquote><blockquote>“CRITICAL”: “Remove unauthenticated access to payment-processor service…”</blockquote><blockquote>},</blockquote><blockquote>“terraform_code”: {</blockquote><blockquote>“CRITICAL”: {</blockquote><blockquote>“description”: “Remove the ‘allUsers’ invoker permission…”,</blockquote><blockquote>“code”: “resource \”google_cloud_run_service_iam_policy\”…”</blockquote><blockquote>}</blockquote><blockquote>},</blockquote><blockquote>“implementation_steps”: [</blockquote><blockquote>“Review current IAM policy”,</blockquote><blockquote>“Apply Terraform code”,</blockquote><blockquote>“Verify changes in Cloud Console”,</blockquote><blockquote>“Test service functionality”</blockquote><blockquote>],</blockquote><blockquote>“testing_recommendations”: [</blockquote><blockquote>“Test unauthenticated access fails”,</blockquote><blockquote>“Test authenticated access succeeds”,</blockquote><blockquote>“Review Cloud Audit Logs”</blockquote><blockquote>]</blockquote><blockquote>}</blockquote><blockquote>```</blockquote><p><strong>Technical Deep Dive: How We Built It</strong></p><p><strong>Frontend Implementation (React/Vite)</strong></p><p>The frontend provides a modern, responsive interface with:<br>- Real-time scan progress indicators<br>- AI-powered job cards with severity breakdown<br>- Interactive findings viewer with filters<br>- Modal displays for AI-generated content (explanations, summaries, proposals)<br>- Loading states and error handling</p><p><strong>Backend Implementation</strong></p><p>The backend is built with <strong>FastAPI</strong> and Google AI SDK:</p><pre><br>class AIService:<br>def generate_explanation(self, finding: Finding) -&gt; dict:<br># Model initialization with fallback logic<br>model = genai.GenerativeModel(&#39;gemini-2.0-flash&#39;)<br># Structured prompt for AI analysis<br>prompt = f&quot;&quot;&quot;You are a cybersecurity expert. Analyze this finding:<br>- Severity: {finding.severity}<br>- Issue: {finding.issue_description}<br>- Risk Score: {finding.risk_score}<br>Provide JSON with: explanation, blast_radius, risk_assessment,<br>priority_score, business_impact, attack_vector, compliance_impact.&quot;&quot;&quot;<br># AI-powered analysis<br>response = model.generate_content(prompt)<br># Parse and return structured data<br>return self._parse_ai_response(response.text)<br></pre><p><strong>Cloud Run Jobs for Asynchronous Processing</strong></p><p>We use <strong>Cloud Run Jobs</strong> for long-running AI operations:</p><p><strong>Scan Processor Job</strong> (`scan_processor.py`):</p><p>- Triggers from Pub/Sub messages</p><p>- Scans Cloud Run service IAM policies</p><p>- Writes findings to BigQuery</p><p>- Handles hundreds of services efficiently</p><p><strong>Propose Job</strong> (`propose_job.py`):</p><p>- Retrieves findings from BigQuery</p><p>- Generates AI-powered analysis</p><p>- Creates comprehensive reports</p><p>- Uploads to Cloud Storage with signed URLs</p><p><strong><em>Note</em></strong><em>: The architecture supports both Cloud Run Jobs (on-demand) and Cloud Run Worker Pools (continuous processing). Jobs are optimal for sporadic scanning, while Worker Pools are better for high-volume, continuous monitoring workloads.</em></p><p><strong>Infrastructure as Code with Terraform</strong></p><p>All infrastructure is deployed using Terraform:</p><ul><li>Artifact Registry for container images</li><li>Cloud Run Services with auto-scaling</li><li>IAM roles with least-privilege principles</li><li>BigQuery tables with partitioning</li><li>Cloud Storage buckets with lifecycle policies</li></ul><p><strong>Challenges and Solutions</strong></p><p><strong>Challenge 1: AI Model Availability</strong></p><p><strong>Problem</strong>: Gemini API models change frequently, causing initialization failures.</p><p><strong>Solution</strong>: Implemented robust fallback logic:</p><pre>def _initialize_ai_model():<br>models_to_try = [<br>&#39;gemini-2.0-flash&#39;,<br>&#39;gemini-1.5-flash&#39;,<br>&#39;gemini-1.5-pro&#39;,<br># … more fallback options<br>]<br>for model_name in models_to_try:<br>try:<br>model = genai.GenerativeModel(model_name)<br>return model<br>except Exception as e:<br>continue<br>raise Exception(&quot;No working AI model found&quot;)</pre><p><strong>Challenge 2: JSON Parsing from AI Responses</strong></p><p><strong>Problem</strong>: Gemini sometimes returns JSON wrapped in markdown code fences (```json).</p><p><strong>Solution</strong>: Strip markdown before parsing:</p><pre>def _parse_ai_response(text: str) -&gt; dict:<br># Remove markdown code blocks<br>text_to_parse = text.replace(&quot;```json\n&quot;, &quot;&quot;) \<br>.replace(&quot;```\n&quot;, &quot;&quot;) \<br>.replace(&quot;```&quot;, &quot;&quot;) \<br>.strip()<br>return json.loads(text_to_parse)</pre><p><strong>### Challenge 3: Async Job Triggering</strong></p><p><strong>Problem</strong>: Traditional Cloud Run client libraries have authentication issues when triggering jobs from within a Cloud Run service.</p><p><strong>Solution</strong>: Use direct REST API calls with access tokens:</p><pre>def trigger_propose_job(job_id: str):<br># Get access token<br>credentials, project = default()<br>credentials.refresh(Request())<br>access_token = credentials.token<br># Make REST API call<br>api_url = f&quot;https://{REGION}-run.googleapis.com/v2/{job_path}:run&quot;<br>headers = {<br>&quot;Authorization&quot;: f&quot;Bearer {access_token}&quot;,<br>&quot;Content-Type&quot;: &quot;application/json&quot;<br>}<br>response = requests.post(api_url, json=payload, headers=headers)</pre><p><strong>Real-World Impact</strong></p><p><strong>Before Zero-Trust Explainer</strong></p><p>- Security engineers spend 2–3 hours per finding to:</p><p>- Research the vulnerability</p><p>- Understand blast radius</p><p>- Assess business impact</p><p>- Write Terraform fixes</p><p>- Total time for 10 findings: <strong>20–30 hours</strong></p><p><strong>After Zero-Trust Explainer</strong></p><p>- AI explanations: <strong>Instant</strong></p><p>- Blast radius assessment: <strong>Automatic</strong></p><p>- Terraform code generation: <strong>Automated</strong></p><p>- Total time for 10 findings: <strong>&lt; 1 hour</strong></p><p><strong>Time savings</strong>: ~90% reduction in remediation time.</p><p><strong>Application Screenshots</strong></p><p>Here’s what the application looks like in action:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*52puuDTz61NCeF1WHa11jw.png" /><figcaption>Home Page</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*esCfTXLnS9FJa-bMLZohzQ.png" /><figcaption>AI Explain Feature</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/614/1*__lqoLKhn87eefTaIXg1dw.png" /><figcaption>AI Summary Feature</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/616/1*5cKWH0EtsHMSHgYVx-BXIg.png" /><figcaption>AI Summary Feature</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/612/1*WeT7HeVhR4-i1ybsQIWjDg.png" /><figcaption>AI Propose Feature</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*lU4Bs7VjKRDFX85nSZVcBg.png" /><figcaption>AI Propose Feature</figcaption></figure><p><strong>Try It Yourself</strong></p><p><strong>Live Demo</strong>: <a href="https://zte-frontend-cvy4lwzu3q-uc.a.run.app/">https://zte-frontend-cvy4lwzu3q-uc.a.run.app/</a></p><p><strong>GitHub Repository</strong>: <a href="https://github.com/prabhakaran-jm/zero-trust-explainer">https://github.com/prabhakaran-jm/zero-trust-explainer</a></p><p>Try the AI Studio prompts: <a href="https://ai.studio/apps/drive/1zJDtAA4MbLprQbdSmbplA0winHk0wDPV-r">https://ai.studio/apps/drive/1zJDtAA4MbLprQbdSmbplA0winHk0wDPV-r</a></p><p><strong>Key Endpoints</strong>:</p><p>- `POST /scan` — Scan a Cloud Run service<br>- `GET /findings/{job_id}` — Retrieve findings for a scan job (optional query params: `severity`, `limit`)<br>- `GET /explain/{finding_id}` — Get AI-powered explanation<br>- `GET /summary/{job_id}` — Get AI-generated executive summary<br>- `POST /propose/{job_id}` — Generate AI report with Terraform fixes (optional: `findings_ids` in body to target specific findings)<br>- `GET /jobs` — List recent scan jobs (optional query param: `limit`)</p><p><strong>What I Learned</strong></p><p><strong>Cloud Run is Powerful</strong></p><p>- Serverless architecture scales effortlessly</p><p>- Cloud Run Jobs are perfect for async workloads</p><p>- Integration with GCP services is seamless</p><p><strong>AI Studio + Gemini Pro is a Game Changer</strong></p><p>- Natural language understanding enables business-focused security analysis</p><p>- Code generation saves hours of manual work</p><p>- Intelligent prioritization helps security teams focus on what matters</p><p><strong>Infrastructure as Code is Essential</strong></p><p>- Terraform makes deployments repeatable and auditable</p><p>- Version control for infrastructure is a must</p><p>- Modular Terraform structure improves maintainability</p><p><strong>Current Limitations</strong></p><p>- Single GCP project scanning (multi-project support coming soon)</p><p>- Cloud Run services only (extending to other GCP resources in future)</p><p>- Manual remediation approval (auto-remediation with workflows in roadmap)</p><p><strong>Next Steps</strong></p><p>Future enhancements we’re considering:</p><p>- <strong>Multi-cloud Support</strong>: Extend to AWS Lambda and Azure Functions</p><p>- <strong>Automated Remediation</strong>: Auto-apply fixes with approval workflows</p><p>- <strong>Slack Integration</strong>: Real-time security notifications</p><p>- <strong>Custom Policy Engine</strong>: Define organization-specific security rules</p><p>- <strong>Historical Trend Analysis</strong>: Track security posture over time</p><p><strong>Conclusion</strong></p><p>Zero-Trust Explainer demonstrates the power of combining <strong>Cloud Run</strong>, <strong>AI Studio</strong>, and <strong>Gemini Pro</strong> to solve real-world security challenges. By transforming raw technical findings into actionable intelligence with AI-generated remediation code, we’re helping security teams move faster and remediate vulnerabilities before they become incidents.</p><p>The application is open-source and available on GitHub. We welcome contributions, feedback, and collaboration!</p><p><strong>Built with</strong>: Python, FastAPI, React, Google AI Studio, Gemini Pro, Cloud Run, Terraform</p><p><strong>For</strong>: Cloud Run Hackathon 2025</p><p><strong>Additional Resources</strong></p><p>- <strong>Architecture Documentation</strong>: [docs/ARCHITECTURE.md](https://github.com/prabhakaran-jm/zero-trust-explainer/blob/master/docs/ARCHITECTURE.md)</p><p>- <strong>AI Studio Prompts</strong>: [docs/AI_STUDIO_PROMPTS.md](https://github.com/prabhakaran-jm/zero-trust-explainer/blob/master/docs/AI_STUDIO_PROMPTS.md)</p><p>- <strong>API Documentation</strong>: [docs/API.md](https://github.com/prabhakaran-jm/zero-trust-explainer/blob/master/docs/API.md)</p><p>- <strong>Deployment Guide</strong>: [docs/DEPLOYMENT.md](https://github.com/prabhakaran-jm/zero-trust-explainer/blob/master/docs/DEPLOYMENT.md)</p><p><strong>Keywords</strong>: #GoogleCloud #CloudRun #AISecurity #GeminiPro #SecurityAnalysis #DevOps #InfrastructureAsCode #Terraform #FastAPI #React #OpenSource</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0704d05da750" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building AI-Powered Sustainable Shopping with GKE, ADK, MCP, and A2A Protocols]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://prabhakaranjm.medium.com/building-ai-powered-sustainable-shopping-with-gke-adk-mcp-and-a2a-protocols-0110a86b31cc?source=rss-c0cac8e853bf------2"><img src="https://cdn-images-1.medium.com/max/782/1*Qtmik2_GZkeDQKNS14jmSA.png" width="782"></a></p><p class="medium-feed-snippet">*I created this piece of content for the purposes of entering the GKE Turns 10 Hackathon*</p><p class="medium-feed-link"><a href="https://prabhakaranjm.medium.com/building-ai-powered-sustainable-shopping-with-gke-adk-mcp-and-a2a-protocols-0110a86b31cc?source=rss-c0cac8e853bf------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://prabhakaranjm.medium.com/building-ai-powered-sustainable-shopping-with-gke-adk-mcp-and-a2a-protocols-0110a86b31cc?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/0110a86b31cc</guid>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Sun, 21 Sep 2025 22:24:03 GMT</pubDate>
            <atom:updated>2025-09-21T22:24:03.890Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Passing the Google Cloud Associate Data Practitioner Certification: My Experience, Study Guide, and…]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">I recently decided to earn the Google Cloud Associate Data Practitioner certification. As someone who strives to maintain a &#x201C;fully&#x2026;</p><p class="medium-feed-link"><a href="https://prabhakaranjm.medium.com/passing-the-google-cloud-associate-data-practitioner-certification-my-experience-study-guide-and-fb51b0274932?source=rss-c0cac8e853bf------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://prabhakaranjm.medium.com/passing-the-google-cloud-associate-data-practitioner-certification-my-experience-study-guide-and-fb51b0274932?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/fb51b0274932</guid>
            <category><![CDATA[google-cloud-platform]]></category>
            <category><![CDATA[certification]]></category>
            <category><![CDATA[data-practitioner]]></category>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Mon, 09 Jun 2025 03:02:35 GMT</pubDate>
            <atom:updated>2025-06-09T03:02:35.835Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Automating DevOps Workstation Provisioning with Terraform, Ansible, and GitHub Actions]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://prabhakaranjm.medium.com/automating-devops-workstation-provisioning-with-terraform-ansible-and-github-actions-c0e3f3d20367?source=rss-c0cac8e853bf------2"><img src="https://cdn-images-1.medium.com/max/1068/1*qnj1ROsOLBHcYxIi5DRsgg.png" width="1068"></a></p><p class="medium-feed-snippet">&#x1F50E; Why Automate DevOps Workstation Provisioning?</p><p class="medium-feed-link"><a href="https://prabhakaranjm.medium.com/automating-devops-workstation-provisioning-with-terraform-ansible-and-github-actions-c0e3f3d20367?source=rss-c0cac8e853bf------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://prabhakaranjm.medium.com/automating-devops-workstation-provisioning-with-terraform-ansible-and-github-actions-c0e3f3d20367?source=rss-c0cac8e853bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0e3f3d20367</guid>
            <dc:creator><![CDATA[Prabhakaran Jayaraman Masani]]></dc:creator>
            <pubDate>Wed, 28 May 2025 19:54:06 GMT</pubDate>
            <atom:updated>2025-05-28T19:54:06.888Z</atom:updated>
        </item>
    </channel>
</rss>