# codeongrass.com

> Technical guides and analysis for AI coding agents — mobile access, session management, multi-agent orchestration, and GEO optimization.

- [Worktree-Relative Deny Rules in OpenCode: Stop Child Agents From Escaping Project Boundaries](https://codeongrass.com/blog/opencode-worktree-relative-deny-rules/): How to configure OpenCode permission rules to keep child agents within their assigned git worktree — external_directory guard, bash restrictions, and per-agent overrides.
- [Linear Agents + GitHub Copilot: Turn Acceptance Criteria Into Draft PRs Without Bypassing Branch Protection](https://codeongrass.com/blog/linear-agents-github-copilot-draft-prs/): How to use Linear + GitHub Copilot to turn acceptance criteria into draft PRs — writing agent-friendly issues, branch protection rules, and agent-specific CI checks.
- [OpenHands Self-Hosting: Run Issue-to-PR Agents in Your Own Sandbox When Compliance Blocks Hosted Coding Agents](https://codeongrass.com/blog/openhands-self-hosting-compliance-sandbox/): How to self-host OpenHands for issue-to-PR workflows when compliance blocks hosted coding agents — sandbox design, LLM routing, access control, and a compliance checklist.
- [Claude Code Hooks: Make "Done" Mean Tests Passed, Not Agent Stopped](https://codeongrass.com/blog/claude-code-hooks-done-means-tests-passed/): How to use Claude Code PostToolUse and Stop hooks to enforce that "done" means tests actually passed — patterns, security rules, and gotchas.
- [Parallel Worktrees + Clash-Style Conflict Prediction: Catch Overlapping Agent Edits Before the Merge Queue Breaks](https://codeongrass.com/blog/parallel-worktrees-conflict-prediction/): How to build a clash predictor for parallel git worktree agent workflows — compare file paths, diff hunks, and symbols across branches before the merge queue breaks.
- [OpenCode Permission Events: Build a Mobile Approval Queue Instead of Polling Session Permissions](https://codeongrass.com/blog/opencode-permission-events-mobile-approval-queue/): How to wire OpenCode permission events into a mobile approval queue — event-driven design, queue schema, mobile UX patterns, and policy placement for remote agent workflows.
- [Claude Code Subagents: Delegate Repo-Wide Search Without Poisoning the Main Context Window](https://codeongrass.com/blog/claude-code-subagents-repo-wide-search/): How to use Claude Code subagents for repo-wide search without polluting the main context window — patterns, gotchas, and when not to bother.
- [How to Store Your API Key Securely When Running Coding Agents on a VPS](https://codeongrass.com/blog/api-key-security-coding-agents-vps/): Three levels of API key security for coding agents on a VPS: env vars, restricted .env files, and secrets managers like bws or Doppler.
- [Run Claude Code or Codex in a Docker Sandbox: Isolation Without Risk](https://codeongrass.com/blog/docker-sandbox-coding-agents-isolation/): Run Claude Code or Codex safely with --dangerously-skip-permissions inside Docker. The container is your security boundary. Here's how to set it up.
- [How to Run OpenAI Codex CLI on a VPS: Setup and Auth Guide](https://codeongrass.com/blog/codex-cli-vps-setup/): Step-by-step guide to running OpenAI Codex CLI on a remote Linux VPS, including the OAuth browser auth workaround and tmux session persistence.
- [Pipelock MCP proxy + HTTPS_PROXY: stop secret exfiltration from prompt-injected tool calls without changing agent code](https://codeongrass.com/blog/pipelock-mcp-proxy-https-proxy-stop-secret-exfiltration/): Prompt injection becomes operationally dangerous when an agent can both read secrets and make network or tool calls. Pipelock addresses that boundary problem by sitting between the agent, MCP servers, and the network. This article is for developers running coding agents locally or in CI who want a p
- [VellaVeto fail-closed policy mode: deny unsafe MCP tool calls by default and require approval for writes](https://codeongrass.com/blog/vellaveto-fail-closed-policy-mode-deny-unsafe-mcp-tool-calls/): Most agent safety controls are advisory until they sit on the tool-call path. VellaVeto is positioned as a runtime proxy for MCP tools: every call is evaluated against policy before execution, and policy failures deny the call. That fail-closed posture matters for agents that can read files, call Sa
- [OpenTelemetry GenAI spans in agent workflows: trace every tool call to find latency loops and token-cost hotspots](https://codeongrass.com/blog/opentelemetry-genai-spans-agent-workflows-trace-tool-calls/): Agent failures rarely look like a single slow request. They look like loops: plan, call tool, retry, summarize, call another tool, exceed budget. OpenTelemetry’s GenAI semantic conventions give developers a portable way to trace those steps with model, token, workflow, and tool-call attributes.
- [Pincer-MCP proxy tokens: keep real API keys out of agent memory while preserving MCP tool access](https://codeongrass.com/blog/pincer-mcp-proxy-tokens-keep-real-api-keys-out-of-agent-memory/): Agents often need credentials to be useful. They also read files, execute tools, and ingest untrusted content. That combination makes plaintext API keys in .env files, shell profiles, and agent config a poor default. Pincer-MCP takes a proxy-token approach: the agent receives a limited token, while 
- [MCP tool-shadowing defenses: detect poisoned tool descriptions and block mid-session tool-definition rug pulls](https://codeongrass.com/blog/mcp-tool-shadowing-defenses-detect-poisoned-descriptions/): MCP tools are not just code endpoints. Their names, descriptions, and schemas are fed to the model so it can decide what to call. That makes tool metadata part of the instruction channel. Tool shadowing and poisoned descriptions abuse that trust by hiding instructions where users rarely look but mod
- [Capability separation for coding agents: combine network sandboxing + egress DLP to contain compromised prompts](https://codeongrass.com/blog/capability-separation-coding-agents-network-sandboxing-egress-dlp/): A coding agent is useful because it has capabilities: it can read a repo, run tests, call tools, and access the network. A prompt injection is dangerous for the same reason. Capability separation reduces blast radius by ensuring no single component has both unrestricted secrets and unrestricted egre
- [Bidirectional MCP scanning pipeline: catch leaks in outbound tool args and injection in inbound tool responses](https://codeongrass.com/blog/bidirectional-mcp-scanning-pipeline-catch-leaks-and-injection/): Most MCP security discussions focus on either secret leakage or prompt injection. In practice, you need both directions. Outbound tool arguments can carry secrets to an attacker-controlled server. Inbound tool responses can carry instructions that compromise the next model step. A useful MCP gateway
- [Always-On Claude Code in Docker: The LAN Exposure You Missed](https://codeongrass.com/blog/always-on-claude-code-docker-lan-exposure-hardening/): Your Claude Code container can curl your router's admin page. Here's the exact finding from a real always-on production setup — and the 3-step hardening fix one developer built, named, and shipped.
- [Configure Claude Code Approval Gates by Project Risk Level](https://codeongrass.com/blog/claude-code-approval-gates-project-risk-level/): You want Claude Code to keep moving on throwaway work and stay careful on production. The same global setting can't do both. Here's the three-tier config that matches gate strictness to actual project risk.
- [What Breaks When You Run Claude Code Over SSH — And Three Fixes](https://codeongrass.com/blog/what-breaks-claude-code-ssh-three-fixes/): SSH into your remote server, start Claude Code, and half the UI is gone — diff viewer, task panels, changed-files sidebar, all of it. Here's why the terminal UI collapses over SSH and how Leo, Claudette, and tmux each solve it differently.
- [Claude Code Remote Control: The Guide Anthropic's 404 Won't Give You](https://codeongrass.com/blog/claude-code-remote-control-setup-guide/): Anthropic's remote control docs page is a 404. Four developers independently built working setups this week. Here's what they made and how to replicate any of them.
- [Argus vs. Coograph: Real-Time Observability for Claude Code](https://codeongrass.com/blog/argus-vs-coograph-real-time-observability-claude-code/): Your Claude Code agent ran for two hours. Now nobody understands what it built — and it never surfaced a single error. Here's the two-tool observability stack that catches drift before it compounds.
- [Tessera vs AgentManage vs Claudette: Parallel Agent GUIs Compared](https://codeongrass.com/blog/tessera-vs-agentmanage-vs-claudette-parallel-agent-guis-compared-2026/): The terminal breaks down the moment parallelism becomes part of your agent workflow. Three independent developers shipped visual command centers in the same week — here's how Tessera, AgentManage, and Claudette actually differ.
- [Automated Quality Gates for Agent Code: Beyond Passing Tests](https://codeongrass.com/blog/automated-quality-gates-agent-generated-code-beyond-passing-tests/): Your agent's PR passed CI. Tests are green. But hardcoded secrets, hallucinated imports, and convention drift all survive standard checks. Here's the three-layer pipeline that catches what tests miss.
- [Claude Code Zombie Sessions: How --resume Burns Your Quota](https://codeongrass.com/blog/claude-code-zombie-sessions-resume-flag-token-drain/): Your Claude Code process survived a WSL disconnect and burned 74% of your quota overnight. Here's how to find zombie sessions, kill them, and stop it from happening again.
- [Why You Keep Hitting Claude Code's Output Limit—And How to Fix It](https://codeongrass.com/blog/claude-code-output-limit-workflow-fix/): You're paying €100/month for Claude Max and hitting the output limit every other session. It's not a billing problem — it's how you're structuring your sessions. Here's the five-part workflow fix.
- [CCC vs Kandev vs Inter-Session Messaging for Parallel Claude Code](https://codeongrass.com/blog/ccc-vs-kandev-inter-session-messaging-parallel-claude-code-sessions/): You're managing 26 Claude Code sessions and you've become the message bus. Three open-source tools shipped this week to fix that — here's which one solves your specific problem.
- [The venv for Claude Code: Reproducible Team Environments](https://codeongrass.com/blog/venv-for-claude-code-reproducible-team-environments/): Your teammate cloned the repo, ran Claude Code, and the agent did something yours never would. The tool versions differ by two majors and the settings.json was never committed. Here's the fix.
- [Cursor vs. Claude Code vs. Codex in 2026: An Honest Breakdown](https://codeongrass.com/blog/cursor-vs-claude-code-vs-codex-2026-honest-breakdown/): You're paying for Cursor, Claude Code, and Codex — and the comparison math isn't obvious. Here's where each tool actually wins, what the token economics look like at heavy usage, and what to cut.
- [Catch Agent Mistakes Before They Execute: Agent Verifier + Conduct](https://codeongrass.com/blog/automated-pre-execution-review-agent-verifier-conduct/): Your agent is about to write an API key to disk. You have 10 seconds to catch it. Here's how to automate that check — before the damage is done.
- [Cut Claude Code Token Usage 98% with Purpose-Built MCPs](https://codeongrass.com/blog/cut-claude-code-token-usage-98-percent-purpose-built-mcps/): Claude Code reads entire files. On a large codebase or an 80K-token SEC filing, that's a budget-destroying habit. Two open-source MCPs cut token usage by 98% — here's the exact wiring.
- [Inside-the-Loop vs. Outside-the-Loop: Evaluating Agent Architectures](https://codeongrass.com/blog/inside-loop-vs-outside-loop-agent-architectures/): Your agent ran. You have no idea what decisions it made along the way. That's not a trust problem — it's an architecture problem.
- [When Should Your Agent Ask Before Acting? A 3-Tier Risk Framework](https://codeongrass.com/blog/when-should-your-agent-ask-before-acting-3-tier-risk-framework/): You're choosing between step-by-step approval and full autonomy — but that's the wrong binary. Here's the 3-tier risk framework that matches oversight to operation blast radius, not agent preference.
- [AI Agent Disaster Postmortems: The 3 Structural Guardrails](https://codeongrass.com/blog/ai-agent-disaster-postmortems-3-structural-guardrails/): Nine seconds. That's how long it took a Claude agent to wipe PocketOS's entire production database and all backups. Here are the three structural controls that would have stopped it — and every incident like it.
- [25 Claude Code Agents in Production: The Hooks Architecture](https://codeongrass.com/blog/claude-code-hooks-multi-agent-architecture/): Someone built a 25-agent autonomous coding org with Claude Code hooks — an Architect, an Engineer, a Reviewer, a CEO that emails weekly summaries. They argue in PR comments. Here's the architecture.
- [How a Coding Agent Deleted a Production Database in 9 Seconds](https://codeongrass.com/blog/how-coding-agent-deleted-production-database-9-seconds/): A Claude-powered agent deleted an entire production database and its backups in 9 seconds. Here's the 3-gate architecture that makes this class of incident impossible.
- [Where to Gate Your AI Coding Agent: A 3-Checkpoint Framework](https://codeongrass.com/blog/where-to-gate-your-ai-coding-agent-3-checkpoint-framework/): Most developers run zero approval gates on their AI coding agents. The other extreme — gating every tool call — just rebuilds a slow human workflow. Here's the minimal 3-checkpoint architecture that covers real risk without the noise.
- [Claude Code vs. Codex for Heavy Users: Limits, Costs, and When to Switch](https://codeongrass.com/blog/claude-code-vs-codex-heavy-users-limits-costs-switching/): You're burning through Claude Code Max sessions. Codex looks tempting. Here's the honest data — limits, degradation curves, and real switching costs — before you migrate.
- [The CORE Agentic Workflow: Task → Plan Review → Approve → PR](https://codeongrass.com/blog/core-agentic-workflow-task-plan-review-approve-pr/): You dispatched an agent. It ran. Now you're staring at a diff you don't fully recognize. Here's the two-checkpoint workflow that keeps human judgment where it matters — before execution, not after.
- [Why Your Claude Agent Ignores Rules Past ~15 Tool Calls](https://codeongrass.com/blog/why-claude-agent-ignores-rules-past-15-tool-calls/): Your Claude agent follows its system prompt for the first dozen tool calls. Then it stops — no error, no warning, the constraint still present, the model no longer honoring it. Here's what's happening and how to fix it architecturally.
- [Hardening Claude Code in GitHub Actions After the CVSS 9.4 CVE](https://codeongrass.com/blog/hardening-claude-code-github-actions-cvss-9-4-cve/): A CVSS 9.4 CVE hit Claude Code CI/CD pipelines in April 2026 — crafted PR titles exfiltrating API keys. Most workflows are still unpatched. Here's the five-control fix.
- [The MCP Server Ecosystem in 2026: Integration Layer for AI Agents](https://codeongrass.com/blog/mcp-server-ecosystem-integration-layer-ai-agents-2026/): The MCP ecosystem is larger than most developers realize — and discovery is the real bottleneck. Working integrations already exist for git, home automation, and messaging. Here's the map, plus a build-vs-find matrix.
- [How I Shipped a Production iOS App Solo with Claude](https://codeongrass.com/blog/how-i-shipped-production-ios-app-solo-with-claude/): A CPO stepped away from iOS in 2014 and came back 12 years later — no team, just Claude. Here's how he shipped BaselineBody at full-team pace.
- [Leo, ADHDev, tmux-notify, AIPass: 4 DIY Control Layers Compared](https://codeongrass.com/blog/leo-adhdev-tmux-notify-aipass-diy-agent-control-layers-compared/): Four indie devs built the same missing layer around AI coding agents in a single week — and named it completely differently. Here's how Leo, ADHDev, tmux-notify, and AIPass actually stack up.
- [The Outer Harness: Why the Real Work in AI Coding Agents Isn't the LLM](https://codeongrass.com/blog/outer-harness-real-work-ai-coding-agents/): The inner harness (Claude Code, Codex) is commoditizing. Four developers shipped the same control plane primitives this week without a shared vocabulary — here's the framework that names what they built.
- [How to Build Human-in-the-Loop Approval Gates for AI Coding Agents](https://codeongrass.com/blog/how-to-build-human-in-the-loop-approval-gates-ai-coding-agents/): Your agent just ran something you didn't ask for. Here's the three-pattern stack — PreToolUse hooks, ThumbGate blocklists, and mobile approval forwarding — that keeps agents fast without giving them a blank check.
- [Prompt Injection in AI Coding Agents: 3 Attack Vectors, 4 Defenses](https://codeongrass.com/blog/prompt-injection-ai-coding-agents-attack-vectors-defenses/): A single PR comment achieves 85% exploit success against Claude Code, Gemini CLI, and GitHub Copilot. Here's the full attack surface and the four-layer defensive stack that actually bounds the damage.
- [Claude Code Ecosystem 2026: Memory, Sync, and Mobile Tools](https://codeongrass.com/blog/claude-code-companion-tools-ecosystem-2026/): Claude Code is powerful but ships without memory, prompt sync, or mobile access. Here's the map of tools serious users are actually reaching for to fill those gaps in 2026.
- [Multi-Agent Monitoring in 2026: Agent Quest, baton-os, teamfuse](https://codeongrass.com/blog/multi-agent-monitoring-agent-quest-baton-os-teamfuse/): Terminal logs don't scale past two agents. Three developers independently shipped monitoring tools in the same week — here's what each one solves, and what none of them solve yet.
- [The Permission Layer Is 98% of Agent Engineering](https://codeongrass.com/blog/agent-permission-layer-architecture/): Only 1–2% of agent code is actual AI logic. The other 98% — permission systems, hook composition, sandboxing, context management, subagent delegation — is what determines whether your agent is safe to run in production.
- [Run Multiple Coding Agents in Parallel with Git Worktrees](https://codeongrass.com/blog/parallel-coding-agents-worktree-isolation-ownership/): Parallel agents feel productive right up until one silently overwrites the other's work. Here's the isolation and oversight framework that stops it from happening.
- [Daytona vs AgentBox vs DIY: Sandbox Runtime for AI Agents](https://codeongrass.com/blog/daytona-vs-agentbox-vs-diy-sandbox-runtime-ai-agents/): Three sandbox runtimes, one painful decision: Daytona (90ms, production-grade, $24M funded), AgentBox (Docker-simple, just launched), or DIY (full control, full maintenance burden). Here's how to actually choose.
- [How to Use Claude Code --teleport to Hand Off Sessions to Your Phone](https://codeongrass.com/blog/claude-code-teleport-hand-off-phone/): You close your laptop — your Claude Code session dies. Here's how to hand off long-running tasks to your phone using --teleport, Remote Control, and always-on cloud VMs.
- [Claude Code on Pro: What's Actually Included Right Now](https://codeongrass.com/blog/claude-code-pro-plan-whats-included/): Anthropic quietly ran a test removing Claude Code from Pro — and your phone app and desktop are still showing different things. Here's what's actually included right now.
- [Claude Code CLI: Root File Access Without sudo Explained](https://codeongrass.com/blog/claude-code-cli-security-root-file-access-without-sudo/): Claude Code CLI can edit root-owned files even when you skipped sudo at install time. Here's what's happening under the hood — and how to audit and harden your setup before it bites you.
- [Build a Hardware Companion for Claude Code Using Anthropic's BLE API](https://codeongrass.com/blog/build-hardware-companion-claude-code-ble-api/): Your Claude Code agent is stuck on a permission prompt and you're not at your desk. Anthropic just released a BLE maker API so you can build a physical device that handles it — here's the full build walkthrough.
- [Bridging Claude Code CLI and Desktop: Sync Settings, MCPs, Sessions](https://codeongrass.com/blog/bridging-claude-code-cli-desktop-sync-settings-mcps-sessions/): You configured MCPs, skills, and settings in the CLI — then opened Desktop and found none of it. Here's the symlink strategy that bridges both clients without trial-and-error.
- [Managing Claude Code Config Sprawl: settings.json, MCP, Skills](https://codeongrass.com/blog/managing-claude-code-config-sprawl/): Your Claude Code setup is probably scattered across six directories and nobody told you. ~/.claude/agents/, the settings.json hierarchy, MCP configs that break on reprovision — here's the audit and organization system that keeps it all together.
- [How to Audit What Your AI Agent Actually Did After the Session](https://codeongrass.com/blog/how-to-audit-ai-agent-post-run-drift/): Your AI agent finished the session. But did it stay on task? Here's the post-run audit to catch silent scope creep — before it compounds into something you can't easily reverse.
- [Why Claude Code PreToolUse Hooks Can Still Be Bypassed](https://codeongrass.com/blog/claude-code-pretooluse-hooks-bypass-blast-radius/): Your Claude Code hooks can block `cat .env` and still leak your secrets. Here's exactly why — and the four-layer stack that actually bounds blast radius.
- [How to Review AI-Generated Code That Ships Faster Than You Can Read](https://codeongrass.com/blog/how-to-review-ai-generated-code-faster-than-you-can-read/): AI agents write code faster than you can read it. Here's the four-checkpoint workflow — scope bounds, approval gates, diff review, test verification — that keeps you genuinely in control without killing the speed.
- [Mobile UI Quality-Control Checklist for AI-Generated Code](https://codeongrass.com/blog/mobile-ui-quality-control-checklist-ai-generated-code/): AI coding agents don't tell you what they silently add — and asking them to review their own work doesn't help. Here's the 8-point checklist that catches what the agent won't.
- [How to Get Claude Code Notifications on Your Phone](https://codeongrass.com/blog/claude-code-notifications-phone/): Claude Code has no built-in notification system. Here's how to get alerted when your session needs attention — from DIY webhooks to real-time approval gates on your phone.
- [The Best Apps to Control Coding Agents from Mobile (2026)](https://codeongrass.com/blog/best-app-to-control-coding-agents-from-mobile/): Grass, Happy Coder, Claude Code Remote Control, Cursor Mobile, and AgentsRoom Mobile all let you control coding agents from your phone. Here's which one fits your setup.
- [How to Set Up Claude Code on Daytona](https://codeongrass.com/blog/how-to-set-up-claude-code-on-daytona/): How to create a Daytona workspace, install Claude Code inside it, and run a fully cloud-based agent — laptop closed, session persistent, optionally accessible from your phone.
- [How to Authenticate Claude Code and Codex on a Headless VPS](https://codeongrass.com/blog/how-to-run-claude-code-on-a-remote-server/): How to SSH into a remote Linux server, install Claude Code, keep it running persistently with tmux, and optionally connect to the session from your phone without a terminal.
- [Hetzner vs DigitalOcean for AI Coding Agents: Which VPS in 2026?](https://codeongrass.com/blog/how-to-run-claude-code-on-a-vps/): How to provision a VPS, install Claude Code, add basic security hardening, and keep sessions running persistently with tmux. Covers DigitalOcean, Hetzner, and AWS EC2.
- [Keep Claude Code Running After SSH Disconnects (tmux Guide)](https://codeongrass.com/blog/how-to-keep-claude-code-running-after-terminal-close/): Claude Code exits when you close your terminal because it receives SIGHUP. tmux is the fix — here's how to set it up, detach, and reconnect, with screen and nohup as alternatives.
- [How to Run Claude Code with tmux on a VPS](https://codeongrass.com/blog/how-to-run-claude-code-with-tmux/): A complete tmux workflow for Claude Code — named sessions per project, multiple parallel agents in separate windows or panes, detach and reattach, and session recovery.
- [How to Access Your Dev Server from Your Phone](https://codeongrass.com/blog/how-to-access-dev-server-from-phone/): Three options for accessing a running dev server from your phone — mobile SSH apps, Tailscale, and Grass for agent-specific workflows that don't need a terminal at all.
- [How to Use Tailscale with Claude Code for Remote Access](https://codeongrass.com/blog/how-to-use-tailscale-with-claude-code/): How to set up Tailscale on a server running Claude Code so you can access the session securely from any network — without opening SSH ports or managing firewall rules.
- [How to Connect to a Remote Dev Server Without SSH](https://codeongrass.com/blog/how-to-connect-to-remote-dev-server-without-ssh/): Four alternatives to SSH for accessing a remote dev server — from web-based terminals to VS Code tunnels to Daytona workspaces — and how Grass replaces SSH entirely for agent workflows.
- [Claude Code Permissions on a Remote VM: Auto Mode vs --dangerously-skip-permissions](https://codeongrass.com/blog/claude-code-keeps-asking-for-permission/): Three options for handling Claude Code's approval gates: disable them entirely with --dangerously-skip-permissions, auto-approve specific tools, or handle them remotely from your phone with Grass.
- [Is There a Mobile App for Claude Code?](https://codeongrass.com/blog/is-there-a-mobile-app-for-claude-code/): Claude Code has no official native mobile app, but three tools let you monitor, control, and approve agent actions from your phone today.
- [Grass vs Cursor: Which Should You Use for Mobile Agent Access?](https://codeongrass.com/blog/grass-vs-cursor/): Cursor's mobile agent and Grass both let you work with coding agents from your phone — but they solve different problems. Here's how to choose.
- [Grass vs Devin: Autonomous Delegation vs Real-Time Agent Oversight](https://codeongrass.com/blog/grass-vs-devin/): Devin handles tasks autonomously in the cloud. Grass keeps you in the loop while your agent works. They're built for different levels of trust and different types of tasks.
- [Grass vs SSH Apps: Which Should You Use to Access Coding Agents from Your Phone?](https://codeongrass.com/blog/grass-vs-ssh-apps/): SSH apps give you a raw terminal on your phone. Grass gives you a mobile-native interface built specifically for coding agents. Here's when each makes sense.
- [Grass vs Claude Code Remote Control: Which Should You Use?](https://codeongrass.com/blog/grass-vs-claude-code-remote-control/): Claude Code Remote Control is Anthropic's built-in answer to mobile agent access. Grass is the independent alternative. Here's how to choose between them.
- [Grass vs Happy Coder: Two Mobile Clients for Claude Code Compared](https://codeongrass.com/blog/grass-vs-happy-coder/): Grass and Happy Coder are both mobile clients for Claude Code. Here's how they differ on architecture, supported agents, and use cases.
- [Setting Up Grass with a Daytona Remote Server](https://codeongrass.com/blog/setting-up-grass-daytona-remote-server/): A complete technical walkthrough for running Claude Code on a Daytona remote workspace and monitoring it from your phone with Grass — including Tailscale setup and troubleshooting.
- [How to Connect Grass to Claude Code](https://codeongrass.com/blog/connect-grass-to-claude-code/): A deep dive into the Grass and Claude Code integration: how sessions are created and resumed, how the permission system works, and how to get the most out of both tools together.
- [Getting Started with Grass in 5 Minutes](https://codeongrass.com/blog/getting-started-with-grass/): Everything you need to go from zero to a live coding agent session on your phone: install the CLI, scan the QR code, and start monitoring in under 5 minutes.
- [How to Approve or Deny a Coding Agent Action from Your Phone](https://codeongrass.com/blog/approve-deny-coding-agent-action-mobile/): When your coding agent needs permission to write a file or run a command, Grass surfaces the request on your phone instantly. One tap to approve or deny — wherever you are.
- [How to Connect Grass to Daytona](https://codeongrass.com/blog/connect-grass-to-daytona/): Run your coding agent on a Daytona workspace and monitor it from your phone with Grass. Your laptop stays off — the agent keeps working.
- [How to Manage Multiple Coding Agents from Your Phone](https://codeongrass.com/blog/manage-multiple-agents-mobile-dashboard/): Running more than one coding agent at a time? Grass lets you monitor all of them from a single mobile app — switching between sessions, handling approvals, and checking diffs.
- [How to Kick Off a Coding Task During Your Commute](https://codeongrass.com/blog/kick-off-coding-task-commute/): Your commute doesn't have to be dead time. With Grass, you can start a coding agent session from your phone and arrive at your desk with the work already underway.
- [How to Review Your Agent's Code Changes from Your Phone](https://codeongrass.com/blog/review-agent-code-changes-phone/): Your agent just finished a feature build. Grass lets you review every file it touched — diffs, syntax highlighting, line numbers — right from your phone.
- [How to Monitor a Long-Running Coding Agent Overnight](https://codeongrass.com/blog/monitor-coding-agent-overnight/): You don't have to sit at your laptop while your coding agent works. Grass lets you monitor it, handle approval gates, and check progress from your phone — overnight or anywhere.
- [What is an agent approval gate?](https://codeongrass.com/blog/what-is-an-agent-approval-gate/): A point in an AI coding agent's task where it pauses and waits for you to confirm or deny an action before continuing.
- [What is an AI coding agent?](https://codeongrass.com/blog/what-is-an-ai-coding-agent/): A program that takes a coding task and executes it autonomously — reading files, writing code, running tests — without you directing every step.
- [What is a remote coding session?](https://codeongrass.com/blog/what-is-a-remote-coding-session/): An active development environment running on a machine other than the one in front of you, accessed over a network connection.
- [What is mobile coding agent orchestration?](https://codeongrass.com/blog/what-is-mobile-coding-agent-orchestration/): Managing multiple AI coding agents — starting tasks, monitoring progress, handling approvals, redirecting work — from a phone instead of a laptop.
- [What is a transient dev server?](https://codeongrass.com/blog/what-is-a-transient-dev-server/): A short-lived, cloud-hosted development environment that spins up on demand and tears down when the task is complete.
- [What is mobile coding agent access?](https://codeongrass.com/blog/what-is-mobile-coding-agent-access/): The ability to monitor, interrupt, and redirect an AI coding agent from your phone — without being at a laptop.