Agent skill

Jules API

by LeoYeAI in LeoYeAI/openclaw-master-skills

Use the Jules REST API (v1alpha) via curl to list sources, create sessions, monitor activities, approve plans, send messages, and retrieve outputs (e.g., PR URLs).

MITAuto-check passedBackend & APIs

Install Jules API

skills CLI
$ npx skills add LeoYeAI/openclaw-master-skills --skill jules-api -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install LeoYeAI/openclaw-master-skills jules-api --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/jules-and-lobster .claude/skills/jules-api && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
jules-api
GitHub stars
2.2k
Token cost
~4.5k tokens
SKILL.md length
1,169 words
Files
4 (incl. scripts)
Skills in repo
972
Repo updated
First seen
Licence
MIT

At a glance

Use the Jules REST API (v1alpha) via curl to list sources, create sessions, monitor activities, approve plans, send messages, and retrieve outputs (e.g., PR URLs).

  • Works in 3 steps: Get an API Key → Connect Your GitHub Repository → Verify Repository Access
  • The user wants to delegate coding tasks to Jules programmatically
  • SKILL.md covers Quick Start, Overview, Before You Start and Base URL & Authentication, plus 5 more sections
  • Runs JavaScript and Shell scripts from its folder; calls curl, node and jq; reaches jules.googleapis.com and jules.google; needs JULES_API_KEY

What it does

Jules API is an agent skill from LeoYeAI/openclaw-master-skills. Use the Jules REST API (v1alpha) via curl to list sources, create sessions, monitor activities, approve plans, send messages, and retrieve outputs (e.g., PR URLs). Use when the user wants to delegate coding tasks to Jules programmatically. Requires JULESAPIKEY env var (obtain from https://jules.google.com/settingsapi).

Its SKILL.md is about 4.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including scripts (for example `_meta.json`, `scripts/jules.js` and `scripts/jules_api.sh`).

It sits in Backend & APIs, covering REST APIs. It works with GitHub. The repository describes itself as: 🧠 Curated collection of 1209+ best OpenClaw skills — weekly updated by MyClaw.ai. The licence is MIT.

When your agent uses it

  • The user wants to delegate coding tasks to Jules programmatically
  • Tasks that involve REST APIs

Example prompts

  • “/jules-api”

Requirements

  • Python 3
  • Node.js
  • A Bash shell
  • A credential in JULES_API_KEY

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Get an API Key
  2. Connect Your GitHub Repository
  3. Verify Repository Access

What it can do on your machine

Read from SKILL.md and the folder at commit e5199b5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (JavaScript and Shell), which the agent can run.

    Shell commands in SKILL.md call:

    • curl
    • node
    • jq
    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • jules.googleapis.com
    • jules.google
    • jules.google.com
    • github.com

    Also links to:

    • developers.google.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • JULES_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Jules API loads about 4.5k tokens when it runs. Until then it costs about 83 tokens; SKILL.md has 1,169 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~83
When it runs · the whole SKILL.md, loaded when a task matches
~4.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from LeoYeAI/openclaw-master-skills at commit e5199b5, republished under its MIT licence (© LeoYeAI). 1,169 words, ~4,492 tokens.

Download SKILL.mdSave it as .claude/skills/jules-api/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
jules-api
description
Use the Jules REST API (v1alpha) via curl to list sources, create sessions, monitor activities, approve plans, send messages, and retrieve outputs (e.g., PR URLs). Use when the user wants to delegate coding tasks to Jules programmatically. Requires JULES_API_KEY env var (obtain from https://jules.google.com/settings#api).

Jules REST API Skill

Quick Start

bash
# 0. Set your API key (required — get one at https://jules.google.com/settings#api)
export JULES_API_KEY="your-api-key-here"

# 1. Verify available sources (pre-flight check)
./scripts/jules_api.sh sources

# 2. Create a session with plan approval and auto PR creation
./scripts/jules_api.sh new-session \
  --source "sources/github/OWNER/REPO" \
  --title "Add unit tests" \
  --prompt "Add comprehensive unit tests for the authentication module" \
  --branch main \
  --require-plan-approval \
  --auto-pr

# 3. Monitor session progress and approve the plan
./scripts/jules_api.sh activities --session SESSION_ID
./scripts/jules_api.sh approve-plan --session SESSION_ID

Note: Use your GitHub username/org, not your local system username (e.g., sources/github/octocat/Hello-World, not sources/github/$USER/Hello-World).

Overview

This skill enables programmatic interaction with the Jules REST API (v1alpha) for delegating coding tasks to Jules, Google's autonomous AI coding agent. It supports:

  • Task Assignment: Create new coding sessions with specific prompts
  • Session Monitoring: Track session state and activities in real-time
  • Plan Management: Approve or review generated plans
  • Messaging: Send follow-up messages to active sessions
  • Result Integration: Retrieve PR URLs and code changes from completed sessions

Before You Start

1. Get an API Key

Create a Jules API key in the Jules web app:

Export it on the machine running the agent:

bash
export JULES_API_KEY="your-api-key-here"
2. Connect Your GitHub Repository

Before the API can operate on a GitHub repo, you must:

  1. Install the Jules GitHub app via the Jules web UI
  2. Grant access to the specific repositories you want Jules to work on
3. Verify Repository Access
bash
# List available sources to verify access and see correct format
./scripts/jules_api.sh sources

You'll see entries like:

json
{
  "sources": [
    {
      "name": "sources/github/octocat/Hello-World",
      "githubRepo": {
        "owner": "octocat",
        "repo": "Hello-World",
        "defaultBranch": { "displayName": "main" },
        "branches": [
          { "displayName": "main" },
          { "displayName": "develop" }
        ]
      }
    }
  ]
}

Base URL & Authentication

PropertyValue
Base URLhttps://jules.googleapis.com/v1alpha
Auth Headerx-goog-api-key: $JULES_API_KEY

All requests authenticate with:

bash
-H "x-goog-api-key: $JULES_API_KEY"

Core Concepts

Resources
ResourceDescription
SourceA GitHub repository connected to Jules. Format: sources/github/{owner}/{repo}
SessionA unit of work where Jules executes a coding task. Contains state, activities, and outputs
ActivityAn individual event within a session (plan generated, message sent, progress update, etc.)
Session States
StateDescription
QUEUEDSession is waiting to start
PLANNINGGenerating execution plan
AWAITING_PLAN_APPROVALWaiting for user to approve plan
AWAITING_USER_FEEDBACKNeeds user input to continue
IN_PROGRESSActively executing the task
PAUSEDTemporarily stopped
COMPLETEDSuccessfully finished
FAILEDEncountered an error
Activity Types
TypeDescription
Plan GeneratedA plan was generated for the task
Plan ApprovedThe plan was approved (manually or auto)
User MessageUser posted a message to the session
Agent MessageJules posted a message
Progress UpdateStatus update on current work
Session CompletedSession finished successfully
Session FailedSession encountered an error

Workflows

Create a session that requires plan approval before execution and automatically creates a PR when complete:

bash
./scripts/jules_api.sh new-session \
  --source "sources/github/octocat/Hello-World" \
  --title "Fix login bug" \
  --prompt "Fix the null pointer exception in the login handler when email is empty" \
  --branch main \
  --require-plan-approval \
  --auto-pr

Why this is recommended:

  • You review and approve the plan before Jules executes changes
  • PR is created automatically on completion
  • Balances automation with human oversight
Option 2: Fully Automated Session (No Plan Approval)

For low-risk or routine tasks in non-sensitive repos, you can skip plan approval:

bash
# Create session without plan approval (use only for low-risk tasks)
./scripts/jules_api.sh new-session \
  --source "sources/github/octocat/Hello-World" \
  --title "Fix typo in README" \
  --prompt "Fix the typo in README.md line 5" \
  --branch main \
  --auto-pr

Warning: Without --require-plan-approval, Jules will automatically approve its own plan and execute changes. Only use this for low-risk tasks in non-critical repos.

Option 3: Interactive Session

Send follow-up messages during an active session:

bash
# Create session
./scripts/jules_api.sh new-session \
  --source "sources/github/octocat/Hello-World" \
  --title "Add API endpoints" \
  --prompt "Add REST API endpoints for user management" \
  --branch main

# Send additional instructions
./scripts/jules_api.sh send-message \
  --session SESSION_ID \
  --prompt "Also add input validation for all endpoints"

API Reference

Sources
List Sources

Lists all connected GitHub repositories.

bash
curl -sS \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sources"

Query Parameters:

ParameterTypeDefaultDescription
pageSizeinteger30Number of sources to return (1-100)
pageTokenstring-Token from previous response for pagination
filterstring-AIP-160 filter (e.g., name=sources/source1)

Response:

json
{
  "sources": [
    {
      "name": "sources/github/octocat/Hello-World",
      "githubRepo": {
        "owner": "octocat",
        "repo": "Hello-World",
        "isPrivate": false,
        "defaultBranch": { "displayName": "main" },
        "branches": [
          { "displayName": "main" },
          { "displayName": "develop" }
        ]
      }
    }
  ],
  "nextPageToken": "..."
}
Get Source

Retrieves a single source by name.

bash
curl -sS \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sources/github/octocat/Hello-World"

Use this to see available branches before creating a session.


Sessions
Create Session

Creates a new coding session.

bash
curl -sS "https://jules.googleapis.com/v1alpha/sessions" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $JULES_API_KEY" \
  -d '{
    "prompt": "Add unit tests for the login module",
    "title": "Add Login Tests",
    "sourceContext": {
      "source": "sources/github/octocat/Hello-World",
      "githubRepoContext": {
        "startingBranch": "main"
      }
    },
    "requirePlanApproval": true,
    "automationMode": "AUTO_CREATE_PR"
  }'

Request Body Fields:

FieldTypeRequiredDescription
promptstringYesThe task description for Jules
titlestringNoShort title for the session
sourceContext.sourcestringYesSource name (e.g., sources/github/owner/repo)
sourceContext.githubRepoContext.startingBranchstringYesBranch to start from
requirePlanApprovalbooleanNoIf true, pause for plan approval. Recommended: true for production repos
automationModestringNoSet to AUTO_CREATE_PR for automatic PR creation

Response:

json
{
  "name": "sessions/31415926535897932384",
  "id": "31415926535897932384",
  "prompt": "Add unit tests for the login module",
  "title": "Add Login Tests",
  "state": "QUEUED",
  "url": "https://jules.google/session/31415926535897932384",
  "createTime": "2026-01-15T10:30:00Z",
  "updateTime": "2026-01-15T10:30:00Z"
}
List Sessions

Lists your sessions.

bash
curl -sS \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions?pageSize=20"

Query Parameters:

ParameterTypeDefaultDescription
pageSizeinteger30Number of sessions to return (1-100)
pageTokenstring-Token from previous response for pagination
Get Session

Retrieves a single session by ID.

bash
curl -sS \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions/SESSION_ID"

Response includes outputs on completion:

json
{
  "name": "sessions/31415926535897932384",
  "id": "31415926535897932384",
  "state": "COMPLETED",
  "outputs": [
    {
      "pullRequest": {
        "url": "https://github.com/octocat/Hello-World/pull/42",
        "title": "Add Login Tests",
        "description": "This PR adds comprehensive unit tests..."
      }
    }
  ]
}
Send Message

Sends a message to an active session.

bash
curl -sS \
  -X POST \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions/SESSION_ID:sendMessage" \
  -d '{"prompt": "Also add integration tests"}'

Use this to provide feedback, answer questions, or give additional instructions.

Approve Plan

Approves a pending plan (only needed if requirePlanApproval was true).

bash
curl -sS \
  -X POST \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions/SESSION_ID:approvePlan"
Delete Session

Deletes a session.

bash
curl -sS \
  -X DELETE \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions/SESSION_ID"

Activities
List Activities

Lists activities for a session.

bash
curl -sS \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions/SESSION_ID/activities?pageSize=30"

Query Parameters:

ParameterTypeDefaultDescription
pageSizeinteger50Number of activities to return (1-100)
pageTokenstring-Token from previous response for pagination

Response:

json
{
  "activities": [
    {
      "name": "sessions/123/activities/456",
      "createTime": "2026-01-15T10:31:00Z",
      "planGenerated": {
        "plan": "1. Analyze existing code\n2. Create test files\n3. Write tests..."
      }
    },
    {
      "name": "sessions/123/activities/457",
      "createTime": "2026-01-15T10:32:00Z",
      "progressUpdate": {
        "title": "Writing tests",
        "details": "Creating test file for auth module..."
      }
    }
  ],
  "nextPageToken": "..."
}

Activities may include artifacts with code changes:

json
{
  "artifacts": [
    {
      "changeSet": {
        "gitPatch": {
          "unidiffPatch": "diff --git a/...",
          "baseCommitId": "abc123",
          "suggestedCommitMessage": "Add unit tests for login"
        }
      }
    }
  ]
}
Get Activity

Retrieves a single activity by ID.

bash
curl -sS \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions/SESSION_ID/activities/ACTIVITY_ID"

Script Reference

Show full SKILL.md (476 more words)Show less
jules_api.sh

The scripts/jules_api.sh script provides a convenient wrapper for common API operations.

Usage:

bash
# List sources
./scripts/jules_api.sh sources

# List sessions
./scripts/jules_api.sh sessions [--page-size N]

# List activities for a session
./scripts/jules_api.sh activities --session <id> [--page-size N]

# Send message to session
./scripts/jules_api.sh send-message --session <id> --prompt "..."

# Approve plan
./scripts/jules_api.sh approve-plan --session <id>

# Create new session
./scripts/jules_api.sh new-session \
  --source "sources/github/owner/repo" \
  --title "..." \
  --prompt "..." \
  [--branch main] \
  [--auto-pr] \
  [--no-plan-approval]

Flags:

FlagDescription
--sourceSource name (format: sources/github/owner/repo)
--titleSession title
--promptTask description or message content
--sessionSession ID
--branchStarting branch (default: main)
--auto-prEnable automatic PR creation
--require-plan-approvalRequire explicit plan approval (default)
--no-plan-approvalSkip plan approval (use for low-risk tasks only)
--page-sizeNumber of results to return
jules.js

The scripts/jules.js script wraps the Jules CLI for programmatic use.

Usage:

bash
node scripts/jules.js version
node scripts/jules.js list-repos
node scripts/jules.js list-sessions
node scripts/jules.js new --repo owner/repo --task "Your task"
node scripts/jules.js pull --session SESSION_ID

Common Error Patterns

"Source not found" or "Repository not found"

Cause: Repository not connected or incorrect source name format.

Solution:

  1. Run ./scripts/jules_api.sh sources to list available sources
  2. Ensure you've installed the Jules GitHub app for this repo
  3. Use the exact source name from the list (e.g., sources/github/octocat/Hello-World)
"Missing JULES_API_KEY"

Cause: API key not set in environment.

Solution:

bash
export JULES_API_KEY="your-api-key"
Authentication Errors

Cause: Invalid or expired API key.

Solution:

  1. Generate a new API key at https://jules.google.com/settings#api
  2. Update the JULES_API_KEY environment variable
  3. Note: You can have at most 3 API keys at a time
Session Stuck in AWAITING_PLAN_APPROVAL

Cause: Session was created with requirePlanApproval: true.

Solution:

bash
./scripts/jules_api.sh approve-plan --session SESSION_ID
Task Fails with Vague Error

Cause: Vague prompts may produce unexpected results.

Solution:

  • Write clear, specific prompts
  • Break large tasks into smaller, focused tasks
  • Avoid prompts that require long-running commands (dev servers, watch scripts)
Large Files Skipped

Cause: Files exceeding 768,000 tokens may be skipped.

Solution:

  • Break down operations on very large files
  • Consider splitting large files before processing

Best Practices

Writing Effective Prompts
  1. Be specific: Instead of "fix the bug", say "fix the null pointer exception in auth.js:45 when email is undefined"
  2. Provide context: Mention relevant files, functions, or error messages
  3. Keep tasks focused: One logical task per session
Monitoring Sessions
  1. Poll session state to track progress
  2. Check activities for detailed progress updates
  3. Handle AWAITING_USER_FEEDBACK state by sending clarifying messages
Security
  1. Never include secrets or credentials in prompts
  2. Review generated PRs before merging
  3. Use requirePlanApproval: true (recommended for all repos, especially production)
  4. Only install the Jules GitHub app on repositories you intend to use with Jules — limit access scope
  5. Treat JULES_API_KEY as a secret: store it securely, rotate it regularly, and never paste it into untrusted places
Performance
  1. Use automationMode: AUTO_CREATE_PR for streamlined workflows
  2. Only skip plan approval (requirePlanApproval: false) for routine, low-risk tasks in non-critical repos
  3. Break complex tasks into smaller sessions

Extracting Results

When a session completes, retrieve the PR URL from outputs:

bash
# Get session details
curl -sS \
  -H "x-goog-api-key: $JULES_API_KEY" \
  "https://jules.googleapis.com/v1alpha/sessions/SESSION_ID" \
  | jq '.outputs[].pullRequest.url'

Known Limitations

  • Alpha API: Specifications may change; API keys and definitions are experimental
  • No long-running commands: Jules cannot run npm run dev or similar watch scripts
  • Context size: Files > 768,000 tokens may be skipped
  • Prompt sensitivity: Vague prompts may produce unexpected results

References

© LeoYeAI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (scripts) in skills/jules-and-lobster of LeoYeAI/openclaw-master-skills.

  • SKILL.md
  • _meta.json
  • scripts/jules.js
  • scripts/jules_api.sh

Open the folder on GitHubat commit e5199b5

Compare with similar skills

Jules API next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Jules API compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Jules API this skillLeoYeAI/openclaw-master-skills2.2k—~4.5kAutomated safety check: PassMIT
Kql ValidatorAzure/azqr795—~703Automated safety check: PassMIT
A2a CLIa2aproject/a2a-cli152—~1.5kAutomated safety check: NotesApache-2.0
Ship Coolifykovrichard/catalyst470—~1.9kAutomated safety check: NotesNone
Readme Generator Probeizhi23/README-Generator-Pro113—~472Automated safety check: NotesNone
Latchkeyimbue-ai/latchkey130—~1.3kAutomated safety check: PassMIT

Similar skills

  • Kql Validator

    Azure/azqr

    Official

    Validate KQL (Kusto Query Language) files used in Azure Quick Review (azqr) against their recommendation definitions.

    795 GitHub stars~703 tokensUpdated 2 days ago
    Backend & APIsAuto-check passed
  • A2a CLI

    a2aproject/a2a-cli

    Delegate work to A2A (Agent2Agent) agents from the command line with the a2a CLI (github.com/a2aproject/a2a-cli).

    152 GitHub stars~1.5k tokensUpdated 6 days ago
    Backend & APIsAuto-check: notes
  • Ship Coolify

    kovrichard/catalyst

    Verify a Coolify deploy end-to-end after a push — wait for GitHub CI, then the Coolify deployment, confirm the commit is live, and run a visual check.

    470 GitHub stars~1.9k tokensUpdated 8 days ago
    Backend & APIsAuto-check: notes
  • Readme Generator Pro

    beizhi23/README-Generator-Pro

    Generate, modify, and render professional README.md files and project introduction HTML pages using the bundled README Generator Pro FastAPI application.

    113 GitHub stars~472 tokensUpdated 3 mo ago
    Backend & APIsAuto-check: notes
  • Latchkey

    imbue-ai/latchkey

    Interact with third-party or self-hosted services (Slack, Google Workspace, Dropbox, GitHub, Linear, Coolify...) using their HTTP APIs on the user's behalf.

    130 GitHub stars~1.3k tokensUpdated 5 days ago
    Backend & APIsAuto-check passed
  • B24phpsdk Maintainer

    bitrix24/b24phpsdk

    A skill your agent uses whenever working with GitHub issues in the bitrix24/b24phpsdk repository: creating new issues, reading existing ones, planning implementation from an issue, referencing an…

    102 GitHub stars~10k tokensUpdated 8 days ago
    Backend & APIsAuto-check: notes

More from LeoYeAI/openclaw-master-skills

All 972 skills in this repo
  • DevOps Pipeline Management

    LeoYeAI/openclaw-master-skills

    Manages pipelines on a DevOps quality and efficiency platform through its OpenAPI: list workspaces and templates, create, update, run and cancel pipelines, and read run records.

    2.2k GitHub stars~4.2k tokensUpdated 2 mo ago
    Auto-check: notes
  • Feishu Document Collaboration

    LeoYeAI/openclaw-master-skills

    Patches OpenClaw's Feishu extension so an edited document triggers an isolated agent session that reads the doc and replies inline, turning it into a live chat space.

    2.2k GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed
  • Files Memory System

    LeoYeAI/openclaw-master-skills

    Multi-context memory management system for OpenClaw agents with group-isolated storage, global shared memory, workspace organization, and group-specific skills isolation.

    2.2k GitHub stars~3.8k tokensUpdated 2 mo ago
    Auto-check passed
  • GEO-Claw AI Visibility Agent

    LeoYeAI/openclaw-master-skills

    Runs a brand's AI-search visibility work end to end: diagnosing how AI platforms represent it, repositioning it, producing AI-optimized content and monitoring ongoing mentions.

    2.2k GitHub stars~4.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Google Workspace CLI

    LeoYeAI/openclaw-master-skills

    Installs and authenticates the gws CLI, then automates Gmail, Drive, Sheets, Calendar, Docs, Chat and Tasks with ready-made recipes, persona bundles and security audits.

    2.2k GitHub stars~2.6k tokensUpdated 2 mo ago
    Auto-check: notes
  • HealthFit Health Advisors

    LeoYeAI/openclaw-master-skills

    Runs four advisor roles, a fitness coach, nutritionist, data analyst and TCM practitioner, to build a health profile and track workouts, diet and wellness over time.

    2.2k GitHub stars~4.4k tokensUpdated 2 mo ago
    Auto-check passed

Works with

Categories

Questions about Jules API

What does Jules API do?

Use the Jules REST API (v1alpha) via curl to list sources, create sessions, monitor activities, approve plans, send messages, and retrieve outputs (e.g., PR URLs). Jules API is an agent skill from LeoYeAI/openclaw-master-skills., PR URLs).

When should I use Jules API?

Jules API fits situations like: the user wants to delegate coding tasks to Jules programmatically; tasks that involve REST APIs.

How do I install Jules API in Claude Code?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill jules-api -a claude-code`. Or copy the skill folder (skills/jules-and-lobster in LeoYeAI/openclaw-master-skills) into .claude/skills/jules-api in your project. Claude Code loads it when a task matches its description.

How do I install Jules API in Codex?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill jules-api -a codex`. Or copy the skill folder (skills/jules-and-lobster in LeoYeAI/openclaw-master-skills) into .agents/skills/jules-api in your project. Codex loads it when a task matches its description.

Can I use Jules API in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add LeoYeAI/openclaw-master-skills --skill jules-api -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/jules-api, .gemini/skills/jules-api, .github/skills/jules-api and .opencode/skills/jules-api in your project.

What does Jules API need to run?

Going by SKILL.md and its folder, Jules API needs JavaScript and a shell for the scripts in its folder, the command-line tools its instructions call (curl, node, jq and npm) and credentials named JULES_API_KEY. Our summary lists: Python 3; Node.js; A Bash shell; A credential in JULES_API_KEY.

Does Jules API access the network?

SKILL.md names 5 domains. In commands or code: jules.googleapis.com, jules.google, jules.google.com and github.com; the agent is likely to contact these when it follows the instructions. As links in the text: developers.google.com. This is read from the text; nothing was executed.

Is Jules API safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Jules API use?

Jules API is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Jules API use?

About 4.5k tokens (SKILL.md is roughly 18k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Jules API?

Skills that share tags, products or a category with Jules API: Kql Validator (Azure/azqr, 795 stars), A2a CLI (a2aproject/a2a-cli, 152 stars), Ship Coolify (kovrichard/catalyst, 470 stars) and Readme Generator Pro (beizhi23/README-Generator-Pro, 113 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Jules API?

LeoYeAI (a GitHub user) maintains it in LeoYeAI/openclaw-master-skills, which has 2,159 GitHub stars. The repository holds 972 skills in this directory. The repository was last updated on July 20, 2026.

Source: LeoYeAI/openclaw-master-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.