Complete Jev setup and install guide

Jev is an AI decision model built for bounded decision tasks such as classification, selection, scoring, routing, filtering, and yes/no judgments.

Reach for Jev when AI needs to make one specific, constrained decision.

Good examples:

• Classify a support ticket
• Pick the correct department
• Score urgency
• Detect refund requests
• Filter important messages
• Route an AI agent
• Decide whether a human should review

Jev performs best when every possible decision is clearly defined.

• Sign up with the service that provides Jev access.
• Finish setting up your account.
• Go to the API settings.
• Generate an API key.
• Store the key somewhere secure.
• Never expose the key publicly.

Depending on the integrations available, you can build Jev into:

• API workflows
• Python applications
• JavaScript applications
• Command-line workflows
• AI coding agents
• Agent Skills
• Automation systems
• Custom AI agents

Jev CLIs are community projects, separate from TypeSafe's official SDKs, so confirm your environment meets your chosen tool's current requirements.

Requirements typically cover:

• A recent Python 3 release
• Terminal access
• curl

Check these against the current CLI release before you install.

Install the latest Jev CLI release.

Once installed, confirm it works by running:

jev --version

If the command is not found, check that the install directory is on your system PATH.

Set your API credentials through the CLI:

jev auth set

Paste your API key at the prompt.

Next, review your authentication status:

jev auth status

Confirm that authentication succeeds:

jev auth test

On servers, containers, CI/CD pipelines, and automated systems, keep credentials in environment variables or a dedicated secret manager.

• Never hardcode API keys into your application code.
• Never commit credentials to a Git repository.

Jev can act as a focused decision layer inside a larger AI agent.

• The agent can gather the information.
• Jev can judge one bounded decision.
• Your application can then carry out the right action.

Splitting decision from execution keeps both easier to control.

Begin by pinning down exactly what Jev must determine.

Common patterns:

Spell out every available choice.

Example:

• Sales
• Billing
• Technical Support
• Refund
• Spam
• Other

Keep categories from overlapping wherever you can.

Give every realistic input a fitting outcome.

An "Other" or "Unknown" option stops ambiguous inputs from being forced into the wrong category.

Avoid:

Is this message useful?

Prefer:

Does this message include specific technical, product, or industry information?

State plainly what qualifies and what does not.

Do not send whole documents, databases, or conversation histories by default.

Send only what the decision actually requires.

Less context can improve:

• Speed
• Cost
• Privacy
• Predictability
• Debugging
• Evaluation

Example:

Input

Customer message

Decision

Which type of request is this?

Choices

Sales, Billing, Technical Support, Refund, Other

Output

Selected category

Your application then decides what happens next.

Jev might conclude:

This is a refund request.

Your application should decide on its own whether it may:

• Issue a refund
• Contact the customer
• Modify an account
• Update a database
• Trigger another workflow

Keeping them apart limits the damage of a wrong classification.

Where confidence information is available and calibrated for your workflow, you can set different handling rules.

Never assume a confidence score is a reliable probability of being correct.

Some decisions should not be fully automated.

A practical workflow can allow:

• Automatic acceptance
• Automatic rejection
• Human review

Apply stricter safeguards to high-impact decisions.

Test:

• Clear cases
• Negative cases
• Ambiguous cases
• Edge cases
• Missing information
• Conflicting information
• Very short inputs
• Long inputs
• Unusual wording
• Adversarial inputs

Never judge the system on ideal examples alone.

Assemble representative inputs paired with known expected outcomes.

Rerun Jev against this dataset every time you change:

• Prompts
• Decision criteria
• Categories
• Application logic
• Model configuration
• Workflow architecture

Track metrics like:

• Accuracy
• Precision
• Recall
• False positives
• False negatives
• Human-review rate
• Latency
• Cost
• Failure rate
• Performance by category

Which metrics matter depends on your use case.

Jev can help decide:

• Which agent responds
• Which tool gets used
• Which workflow runs
• Which department receives an item
• Whether to escalate
• Whether a human must step in

Classification workflows can cover:

• Support tickets
• Emails
• Documents
• Leads
• User requests
• Feedback
• Content
• Logs
• Product issues

Jev can also handle bounded scoring tasks.

Examples:

• Urgency
• Priority
• Relevance
• Lead quality
• Review priority
• Content quality
• Risk indicators

Define exactly what each score means.

A typical workflow runs like this:

• Receive the input
• Prepare relevant context
• Send the decision request
• Receive a structured decision
• Validate the response
• Apply business rules
• Execute the permitted action
• Log the result
• Escalate uncertain cases

Never trust model output blindly.

Validate:

• Output format
• Allowed values
• Required fields
• Data types
• Missing responses
• Unexpected responses
• API failures
• Timeouts

Make your application recover gracefully from:

• API errors
• Authentication failures
• Rate limits
• Timeouts
• Invalid responses
• Missing data
• Network problems
• Unexpected classifications

Retry only where it makes sense.

Log enough detail to explain how the system behaved.

Useful fields:

• Decision requested
• Decision returned
• Confidence information, where available
• Timestamp
• Model configuration
• Latency
• Final action
• Human override

Do not log sensitive information you do not need.

Keep watching:

• Incorrect decisions
• Unexpected inputs
• Latency
• API failures
• Costs
• Human overrides
• Category distribution
• Decision drift

Performance can shift as real-world inputs shift.

Never:

• Commit it to GitHub
• Place it in frontend JavaScript
• Show it in screenshots
• Expose it in browser code
• Publish it in documentation
• Share it publicly

Keep it in environment variables or a secure secret manager.

A decision model should never get unlimited permissions by default.

Grant downstream systems only the minimum permissions their intended actions require.

Gate high-impact actions behind stronger validation or human approval.

Strong first projects:

• Email categorization
• Support routing
• Lead classification
• Document categorization
• Content tagging
• Intent detection
• Priority classification

Expand the workflow step by step once performance is validated.

• Jev access
• API credentials
• API, CLI, or supported integration
• Clearly defined decision
• Bounded answer space
• Relevant input
• Output validation
• Application logic
• Human fallback
• Evaluation dataset
• Logging
• Monitoring
• Security controls