Activity
379 followers
-
Leonid Y. shared thisCloud Run already had three execution models: Services (request-response), Jobs (batch), and Worker Pools (background). When Google introduced Cloud Run Instances, I was confused. Why a fourth option? At first, I thought it was about local storage for AI agents. But Services already support volume mounts and ephemeral disks. My actual "aha" moment came from connection lifetimes. Many AI agents operate long-lived sessions over WebSockets to stream continuous updates. Cloud Run Services have a hard maximum request timeout of 60 minutes (defaulting to 5). For an agent that needs to run for days, the connection drops. That is the gap Instances fill. A few practical applications: -> Always-On Personal Agents & Engines: Running tools like n8n or OpenClaw with a permanent HTTPS URL that never times out. -> Instant Bastion Hosts: A secure, on-demand jump-box to access private Cloud SQL instances without provisioning a full Compute Engine VM. -> Code Sandboxes: An isolated, single-node execution environment paired with Cloud Run Sandboxes. The Trade-offs to keep in mind: Strict Singleton: No autoscaling. If traffic spikes, requests queue and time out. State is still ephemeral: Ephemeral disks give you fast local scratch space, but mandatory 1–2 week maintenance restarts will wipe memory and local disk. Durable state still requires an external database or bucket. The Cloud Run Cheat Sheet: -> Scale-to-zero web app with bursts: Service -> 5-hour batch script: Job -> Queue processor without a public URL: Worker Pool -> Cheap ($5.70/mo for 1GiB), single-node environment with a permanent URL that holds connections for days: Instance One terminology tip: be precise when talking about "Cloud Run Instances" (the resource type) versus container instances of a Service that are spun up to scale a workload. Full deep dive on storage limits and architecture details on my blog: https://lnkd.in/gDTTgziF
-
Leonid Y. posted this**𝗬𝗼𝘂𝗿 𝘀𝗸𝗶𝗹𝗹𝘀 𝗮𝗿𝗲 𝗻𝗼𝘁 𝗺𝘆 𝘀𝗸𝗶𝗹𝗹𝘀** When AI skills started popping up everywhere, my first impulse was to collect them like browser extensions. But treating skills like plug-and-play software misses a fundamental truth: a skill isn't just a package; it's a piece of someone's thinking. In the real world, relying on someone else's knowledge is never the same as using your own head. You can read someone’s notes or memorize their checklist, but until you understand the principles yourself, you can't adapt when things go sideways. AI skills operate on that exact same principle. Every time I sit down to write code using an agent, the goal is simple: get things done quickly, but not compromise code quality or ignore best practices. At the beginning, I tried making tasks work using published skills. I spent time trying skills from public repositories by Anthropic, Microsoft and Google as well as some community repos (e.g. Matt Pocock's). Using out-of-the-box skills rarely produced the desired result for me. Even when the name and description sounded perfectly like what I needed, once the agent started working, it was following the original author's assumptions, shortcuts, and trade-offs. My initial reaction was to go to the other extreme: write all my skills from scratch. But that comes with its own hurdle. It takes a lot of time, and it’s often hard to know where to even begin. Translating the intuitive, tacit understanding that already lives in your head into finely tuned instructions for an agent is a long, demanding process. In practice, the most effective path is often in between: read through existing public skills, understand the logic under the hood, and improve them to your liking. Or even better, merge parts from a few off-the-shelf skills into a new one tailored to your exact workflow. Skills don't replace your domain knowledge. They don't eliminate the need to know what a good solution looks like. All they do is encode your mental model into the agent—eliminating the frustration of having to micromanage it with repetitive follow-up instructions. Off-the-shelf skills are like books on a topic: useful references, but they don't always solve your exact problem to your satisfaction. A skill you refine yourself gives an agent your own understanding, judgment, and style, so it actually works the way you would do it. Of course, if your strategy is just delegating your job to other people, go right ahead and use their skills or their agents.
-
Leonid Y. posted thisA quick follow-up to my previous post on securing API keys (https://lnkd.in/gYTXzJ5u): Since then, the Google Cloud Console has introduced visual notifications and policy constraints to block the creation of unsecured API keys and alert on existing ones. However, finding all active keys across every Google Cloud project you have access to is still tedious. To make this straightforward, I built a simple front-end tool: Google Cloud API Keys Finder 🔍 What it does: • Scans all accessible Google Cloud projects for active API keys. • Audits each key's protection level (Application Restrictions & API Scopes). • Delivers clear, actionable recommendations to remediate security risks. 🔒 100% Client-Side & Private: It is a pure front-end application with no backend and zero data storage. Tokens and keys reside strictly in temporary browser memory. You are welcome to inspect the source code and run it locally: 👉 GitHub: https://lnkd.in/gG9nGc8w If you want step-by-step guidance on locking down your keys, check out the Google Codelab: 🛠️ API Key Management and Security: https://lnkd.in/gic8JBSJ Original deep-dive article: 📖 https://lnkd.in/gQuJhqb7 (also at https://lnkd.in/gQixdY-W) Questions, feedback, or suggestions? Let's discuss in the comments! #GoogleCloud #GCP #CloudSecurity #APISecurity
-
Leonid Y. shared thisHow do you keep sensitive data out of your LLMs without breaking your agent's function calls? 🛡️ If you systematically scrub every piece of sensitive data on ingress, your downstream tools will fail (e.g., an agent can't query a backend database if you replaced the user's account number with a `[REDACTED]` placeholder). In Part 3 of my "How to wear Model Armor" series, I walk through exactly how to solve this routing problem. While you can deploy this mitigation strategy outside of GCP, running it natively on Google Cloud using Sensitive Data Protection (SDP) and Model Armor provides the biggest benefits for centralized governance and performance. Here is how to orchestrate it: 💡 Use Model Armor for your zero-trust boundaries (User-to-Agent ingress and egress) to enforce centralized, no-code data policies across your organization. 💡 Use Direct SDP API calls inside your tool implementations to scrub "Hidden Ingress"—the massive, structured JSON payloads your own backend APIs return to the LLM. 💡 If you must let sensitive data into the context window for a tool to execute, proactively prune the conversational history immediately after the call succeeds to enforce the Principle of Least Privilege. Read the full breakdown on how to architect this data flow here: https://lnkd.in/gtF8aXNq #GoogleCloud #GenerativeAI #Cybersecurity #DataPrivacy #ModelArmor #SoftwareArchitecture
-
Leonid Y. shared thisYesterday I presented the in App Builders track (Track 3) at the Build with Gemini event in Seattle. It was first Hackathon that I ran in 4 years. And I was amazed to see the variety of applications that attendees created under 2 hours with a minimal guidance. Looking for hands-on experience of building an application with or without coding knowledge or explore how AI can help you wrangle your herd of agents? Look for "Build With Gemini" event in your geographic area. #buildwithgemini #googlecloud #cloudbuilders P.S. I did my best to find among 7 pictures of me speaking the least awkward one. Why do I have a feeling that I failed? 😅
-
Leonid Y. shared this🔒 Are your Google Cloud IAM roles broader than they need to be? Enforcing the Principle of Least Privilege (PoLP) isn't just about assigning predefined roles—it’s about defining under what exact conditions those permissions can be exercised. In my latest Google Cloud Blog post, "Generosity Under Conditions: Hardening Google Cloud Access Management," I dive into how to use IAM Conditions and Common Expression Language (CEL) to achieve surgical precision over permissions. 💡 What’s inside: Constraining Admin Power: How to grant roles/resourcemanager.projectIamAdmin to CI/CD service accounts while restricting them to only grant a specific, whitelisted set of roles (with code for both gcloud and Terraform). Securing AI & MCP Integrations: Scoping the broad roles/mcp.toolUser role down to specific Model Context Protocol (MCP) services or individual MCP tools (e.g., restricting BigQuery MCP execution). Time-Based Restrictions: Enforcing access controls based on business hours and time zones. Defense-in-Depth: Combining Allow policies with IAM Deny policies. Check out the full post with code examples here: 🔗 https://lnkd.in/g5wvGjxS #GoogleCloud #IAM #CloudSecurity #DevOps #CyberSecurityGenerosity Under Conditions: Hardening Google Cloud Access Management | Google Cloud BlogGenerosity Under Conditions: Hardening Google Cloud Access Management | Google Cloud Blog
-
Leonid Y. posted this🎙️ 𝗗𝘂𝗻𝗻𝗼 𝗦𝗲𝗲𝗺𝘀 𝘁𝗼 𝗕𝗲 𝘁𝗵𝗲 𝗛𝗮𝗿𝗱𝗲𝘀𝘁 𝗪𝗼𝗿𝗱 𝗳𝗼𝗿 𝗠𝗼𝗱𝗲𝗹𝘀 Recently, I've been using a CLI agent (Antigravity if you wondered) to help me with my front-end application. I was struggling to troubleshoot an annoying problem: everything worked well locally, but failed when deployed to the cloud. After finding myself explaining to the agent for the fourth time why its latest suggestion wouldn't work, I caught myself thinking: Why can't it simply say "Sorry, I dunno"? It was obvious from our dialog that the agent got stuck and out of ideas. There was no other explanation for these repetitive suggestions. Thinking back about my other experiences with different models (and agents), I realize that when exploring a complex problem, a model will happily spin in circles, repeating very similar arguments again and again until forced to stop. Maybe strict system instructions or incorporating a sub-agent that will track the latest conclusions to catch and stop going in cycles is a solution. However, I wonder why such an important function isn't a part of the models in the first place. Looks like I found a way to make models fail the Turing test. At least today's models. I’m not a data scientist, so I genuinely wonder: why are general models fine saying "Sorry, I can't fulfill this request" but incapable of admitting "I just don't know"? Does it happen in specialized domains too? I don't want to imagine a radiologist using a specialized model to read MRI scans and getting a plausible explanation from the model instead of "I don't know what is happening". Still, the experience of chatting with modern models, well, agents, is really nice. Reminds me of some of my stubborn friends 🙂. Have you hit this same wall in your own workflow? I’d love to hear your thoughts in the comments!
-
Leonid Y. reposted thisLeonid Y. reposted thisEveryone warns you that agents will burn your tokens or hallucinate a fact. Those are the boring failures. The one that actually cost me an afternoon was a rate limit I didn't know GitHub had. Here's the thing nobody prepped me for: an agent touches your systems at a volume and shape no human ever produced. It doesn't browse—it queries, constantly. So it trips failure modes your own usage never could, and you don't see them coming because they were never a problem when a person was at the keyboard. Exhibit A. My `gh` commands started failing mid-afternoon. Same commands that worked an hour earlier. My first thought was *am I about to get banned?* It wasn't a ban. GitHub meters REST and GraphQL on two separate budgets—different sizes, independent refill clocks—and my agent had drained the GraphQL one to zero while REST sat almost full. I'd been failing against an empty bucket right next to a full one I didn't know existed. Why GraphQL and not REST? Because GraphQL bills by points, not requests. A query's price is how much it could return—page sizes multiplied across nested connections. My PR-review pipeline enumerated open review threads across every repo, all day, and every one of those lookups is a GraphQL query. A human clicking the UI would basically never hit it. My agent emptied it before lunch. The fix falls straight out of "two budgets": a lot of what agents reach for—reading a file, listing issues, fetching a PR—has a perfectly good REST endpoint. Route that work through REST and it never touches GraphQL. Two buckets, roughly double the headroom. The general rule: profile what your agents actually do, then check the budgets that behavior spends. Don't assume human-shaped usage. They aren't human-shaped. I wrote the whole thing up—how to read both budgets in one line, how to make a query report its own price, and the routing that keeps your agent off the empty bucket. There's also a ready-made skill in there you can hand your own coding assistant so it never trips this. It's all in the post: https://lnkd.in/gic4MWKp What's a failure your agent hit that a human on the same system never would? #AIAgents #DeveloperExperience #GitHubGitHub Gives You Two Rate Limits. You're Only Using One.GitHub Gives You Two Rate Limits. You're Only Using One.
-
Leonid Y. shared thisIf you saw my recent post on the Google Cloud Blog (Secure Gemini and Google API keys), you know the core problem: API keys aren’t tied to your identity. If someone finds the string, they own the paid tokens. The blog laid out the blueprint for proper hygiene - restricting blast radius, auditing old keys, and watching consumption metrics. Theory is nice but the practice is better. The newly published Google Codelab translates that theory into the practice by walking you through the exact commands and scripts needed to rediscover old keys and protect your environments. Go from reading about it to implementing it: 👉 Run the Codelab: https://lnkd.in/gpzKhFQz 📖 Catch up on the original blog post: https://lnkd.in/gQuJhqb7Securing Your Gemini and Google API Keys | Google Cloud BlogSecuring Your Gemini and Google API Keys | Google Cloud Blog
Leonid Y. replied to a comment
3mo
Brian Harber, apologies with answering to your question with a question: why do you need to observe internal model activity? besides the cost (both monetary and in performance) it wouldn't help to troubleshoot a problem because it requires a very specialized set of skills and would be hard to reproduce. As a software engineer, I'm looking at a model as a black box (binary library). If the quality of its performance doesn't fit me, I can shop for a different black box.
If you are in business of developing LLMs (training or fine-tuning) it might be a different story.
Leonid Y. replied to a comment
3mo
Aratrika Sen, I think that you are referencing system instructions for the agent. In my opinion, the instructions are usually tightly related to the business logic of the agent, so it isn't possible to recommend exact phrases. I'd suggest to always provide a method for grounding the findings. It increases the cost because introduces at least one additional "iteration" between an agent and a model. But it greatly improves the quality of the agent's response. You can also fiddle the temperature configuration to balance between "creativity" of the model and strictness of the responses.
Leonid Y. replied to a comment
3mo
+1 to Aakash's response. Speaking about Agent Platform Evaluation service that we showed, the test result comes with the status (failed or succeed) and a note from the service explaining the findings. These notes can be combined with code analysis and possibly past evaluation results and code changes to research the root cause.
Conventional unit or system testing can crash with a callstack but it only points to "where" and often does not help to understand "why"
Experience & Education
Licenses & Certifications
-
Linux Foundation Certified Kubernetes Application Developer (CKAD)
The Linux Foundation
Issued ExpiresCredential ID CKAD-2000-004455-0100
Volunteer Experience
Languages
-
Russian
Native or bilingual proficiency
-
Hebrew
Full professional proficiency
-
English
Full professional proficiency
Recommendations received
4 people have recommended Leonid
Join now to viewExplore more posts
Explore top content on LinkedIn
Find curated posts and insights for relevant topics all in one place.
View top content