​
Overview

It is still in experimental phase and is not yet complete. In case of any issues, please reach out to us on Discord or email.
The julep CLI is a comprehensive command-line interface for interacting with the Julep platform. Following are the available commands.

​
Authentication

julep auth
The julep auth command is used to authenticate your Julep CLI. This will prompt you to enter your API key and save it to the configuration file.Example:
# Basic authentication with interactive prompt
julep auth

# Output:
# Enter your Julep API key: **********************
# Authentication successful!
You can get your API key from the Julep Dashboard.

​
Project Management

julep init --template "Template Name" --path "Destination Path" --yes
The julep init command is used to initialize a new Julep project using a predefined template. You can check the list of available templates in our library.
​
--template
string
required
Name of the template to use from the library repository (default: “hello-world”)
​
--path
string
Destination directory for where you want to initialize the project (default: current directory)
​
--yes
boolean
Skip confirmation prompt
Examples:
# Initialize a project with the default template (hello-world template)
julep init

# Initialize a project with a specific template
julep init --template "profiling-recommending" --path "./my-project" # Will be initialized in ./my-project/profiling-recommending

# Initialize a project and skip confirmation
julep init --yes

​
Task Execution

julep run --task <task_id> --input '{"key": "value"}'
The julep run command is used to execute a task.
​
--task
string
required
ID of the task to execute
​
--input
json
Input data for the task
​
--input-file
string
Path to a json file containing the input to execute the task with
​
--wait
boolean
Wait for the task to complete before exiting, stream logs to stdout
Examples:
# Run task with inline JSON input
julep run --task "00000000-0000-0000-0000-000000000000" --input '{"prompt": "Write a story about a magical forest"}'

# Run task with input from file
julep run --task "00000000-0000-0000-0000-000000000000" --input-file ./inputs/story-params.json

# Run task and wait for completion
julep run --task "00000000-0000-0000-0000-000000000000" --input '{"style": "watercolor"}' --wait

# Run task that doesn't require input (empty object)
julep run --task "00000000-0000-0000-0000-000000000000" --input '{}'

# Invalid task ID
julep run --task bad-id --input '{}'
# -> Error creating execution: Task not found

​
Agent Management

The commands in julep agents are used to manage your agents. 
julep agents create --name "Agent Name" \
                   --model "Model Name" \
                   --about "Agent Description" \
                   --metadata '{"key": "value"}' \
                   --instructions "Instruction"
The julep agents create command is used to create a new agent.
​
--name
string
required
Name of the agent
​
--model
string
Model to be used (e.g., gpt-4). You can find the list of models here
​
--about
string
Description of the agent
​
--metadata
json
Additional metadata (JSON format)
​
--instructions
string
Instructions for the agent (can be repeated)
​
--definition
string
Path to agent definition file
Examples:
# Create a basic agent
julep agents create --name "Story Writer" --model "gpt-4"

# Create agent with full configuration
julep agents create \
  --name "Content Assistant" \
  --model "gpt-4" \
  --about "AI assistant for content creation" \
  --metadata '{"type": "content", "version": "1.0"}' \
  --instructions "Focus on creative writing" \
  --instructions "Maintain professional tone"

# Create agent from definition file
julep agents create --definition ./agents/content-assistant.yaml
Note: When creating an agent, the agent doesn’t get automatically imported to the project. You can run julep import --agent --id <agent-id> to import the agent to the project.

​
Task Management

julep tasks create --name "Task Name" \
                  --agent-id agent_id \
                  --definition path/to/task.yaml \
                  --metadata '{"status": "beta"}' \
                  --inherit-tools
The julep tasks create command is used to create a new task.
​
--agent-id
string
required
ID of the associated agent
​
--name
string
Name of the task
​
--definition
string
Path to task definition file
​
--metadata
json
Additional metadata (JSON format)
​
--inherit-tools
boolean
Inherit tools from agent
​
--import-to
string
Import to project after creating

​
Tool Management

julep tools create --name "Tool Name" \
                  --type tool_type \
                  --agent-id agent_id \
                  --definition path/to/config.yaml
The julep tools create command is used to create a new tool.
​
--agent-id
string
required
ID of the associated agent
​
--name
string
required
Name of the tool
​
--type
string
required
Type of the tool
​
--definition
string
Path to tool definition file
​
--description
string
Description of the tool
​
--metadata
json
Additional metadata (JSON format)
​
--import-to
string
Import to project after creating

​
Execution Management

julep executions create --task task_id --input '{"key": "value"}'
The julep executions create command is used to create a new execution for a task.
​
--task
string
required
ID or name of the task to execute
​
--input
json
JSON string representing the input for the task (defaults to )
​
--input-file
string
Path to a file containing the input for the task
The CLI will soon include a julep assistant command that launches an interactive prompt for generating commands from plain language. This feature is still under development.

​
Miscellaneous

julep --version
The julep --version or julep -v command displays the current version of the Julep CLI.

​
Best Practices

Project Organization

  • Keep agent, task, and tool definitions in separate directories under src/
  • Use meaningful file names that reflect their purpose
  • Follow the standard project structure

Version Control

  • DO commit julep.yaml to version control
  • DO commit julep-lock.json to version control
  • Document project dependencies and requirements

Command Line Usage

  • Use --json flag for machine-readable output
  • Use --quiet for scripting and automation
  • Always provide required parameters

​
File Management

  • Project Configuration: Keep your julep.yaml clean and well-organized
  • Lock File: Use julep-lock.json to track remote state and relationships
  • Source Files: Organize definitions in appropriate directories under src/

​
Workflow Tips

  • Use julep sync regularly to keep local and remote states in sync
  • Review changes with --json output before applying updates
  • Use the assistant mode for complex workflows: julep assistant

​
Security Best Practices

  • Store API keys securely
  • Use environment-specific configurations
  • Review permissions before executing destructive commands
  • Use --force flags cautiously
Always review the changes before using force flags (--force-local, --force-remote) as they can override remote or local state.

​
Support

If you need help with further questions in Julep: