OPEN GOALS. AI-AUTHORED TOOLS. A JEV LOOP.

Give AI a goal.
Let Jev find
the next step.

Give your AI an open goal. It writes a task script with tools, observations and a completion check. Jev runs the loop, choosing the next tool and parameters as new evidence arrives.

Explore the task designs Give your AI the contract

Python 3.10+MITv0.1.17

An independent Apixly Python runtime for AI-authored task scripts, dynamic tool choices and checked outcomes.

TASK CONTROL ROOMTASK CONTRACT

OPEN GOALFind suitable tools. Save a sourced comparison.

FRESH OBSERVATION

new links7

evidenceupdating

next routeJev →

TOOLS DEFINED BY AI

inspect_page

follow_link ← Jev

read_evidence

record_evidence

Jevchooses from current evidence

DYNAMIC PARAMETER CHOICE

follow_link(
 link_ref="observed-7")

↻

New evidence. A new decision.Stop when the output passes its independent check.

BOUND THE EFFECTS. DISCOVER THE ROUTE.

Fresh observations / Dynamic candidates / Checkable artifacts

PRIMARY AIDefines the task script

Goal, tools, candidate providers and independent completion checks.

JEVChooses the next move

Uses current context to select tools and meaningful parameter candidates.

TRUSTED CODEExecutes and checks

Collects observations, binds real values, applies limits and verifies artifacts.

01 / DESIGN FOR OPEN TASKS

Write the tools.
Discover the path.

Three task examples show how to define capabilities once and let each observation guide the next tool call. Explore the goal, tools and output contract.

research_task.py / example tool callsTASK EXAMPLE

START WITH WHAT IS KNOWN

The script supplies starting pages and requirements. Jev discovers useful sources as it explores.

inspect_page(page="starting-docs")

LET THE OBSERVATION OPEN THE ROUTE

A page reveals documentation and release links. Jev selects a newly observed link, then a relevant section.

follow_link(link_ref="observed-link-7")

FOLLOW THE EVIDENCE

Jev can check a newer release, compare a second source, and record evidence against the task requirements.

record_evidence(source_ref="release-section", field="offline_support")

OUTPUT CONTRACTcomparison.json + source references

Reopen the comparison and check three distinct tools, each requirement and its supporting sources.

OPEN RESEARCH / TASK DESIGN

Start with a question.
Find the useful sources.

Find three self-hosted tools that meet given constraints and save a sourced comparison. Which pages, sections and versions matter is discovered during the run.

AI WRITES: Browser tools, dynamic link/section candidates, evidence recorder, artifact check.
JEV CHOOSES: Next page → section → evidence field → whether more evidence is needed.
BOUND / CHECK: Allowed origins and steps; independently verify three tools, all requirements and cited sources.

Read the open-task design ↗

Extend the task with a registered trusted generator for search terms or prose. Jev can select that tool and continue using its returned candidates.

diagnose_repo.py / example tool callsTASK EXAMPLE

OBSERVE THE FAILURE

The script supplies a repository snapshot and an installed-package failure. Jev follows the evidence to locate the cause.

read_artifact(artifact_ref="wheel-failure")

CHOOSE WHAT TO INSPECT

Jev chooses among newly observed source files, package contents and existing check records.

inspect_package(entry_ref="observed-module")

TEST THE EXPLANATION

A recorded check contradicts the hypothesis. Jev can inspect another artifact or source relationship.

read_artifact(artifact_ref="installed-import-result")

OUTPUT CONTRACTdiagnosis.json + source checks

Check that the saved diagnosis links the recorded failure to captured source revisions and artifacts.

REPOSITORY / TASK DESIGN

Follow the failure.
Find the cause.

Investigate why recorded repository tests passed while an installed package failed. Read files and existing artifacts, then save a diagnosis supported by those sources.

AI WRITES: Read-only repository tools, existing failure artifacts and source checks.
JEV CHOOSES: Which file, artifact or source relationship to inspect after each result.
BOUND / CHECK: Permitted snapshot and artifacts; verify saved references and evidence.

Read the diagnosis design ↗

Use read-only tools to connect failure artifacts with source evidence. Save the diagnosis as a separate artifact.

investigate_api.py / example tool callsTASK EXAMPLE

INSPECT A SYNTHETIC FAILURE

The script supplies a synthetic task entry and read-only status, schema and event tools.

read_status(task_ref="synthetic-17")

FOLLOW A NEW DEPENDENCY

The response reveals a dependency. Jev chooses which observed resource and event page to read next.

read_events(resource_ref="observed-dependency-2", page="observed-1")

CHECK THE SOURCE CONTRACT

Jev reads the source contract, compares it with status and events, and records a source-linked diagnosis.

read_schema(schema_ref="observed-state-contract")

OUTPUT CONTRACTincident-evidence.json + source state checks

Save source state and diagnostic evidence, then independently check the diagnosis against those sources.

CONTROLLED API / TASK DESIGN

Follow the response.
Map the dependencies.

Investigate a synthetic task through a read-only API. Status, event pages and newly discovered dependencies guide the next choice.

AI WRITES: Allowed API scope, resource readers, recorded events and independent source checks.
JEV CHOOSES: Which observed resource, dependency or event page to inspect next.
BOUND / CHECK: Read-only tools and request limits; recheck source state and the saved evidence.

Read the API investigation design ↗

Read-only resource investigation, with a source-linked diagnosis saved as the task artifact.

02 / FROM INTENT TO EXECUTION

One task contract.
Many possible routes.

Explore the architecture ↗

01 / AUTHORAI writes the capability

Tools, candidate providers, observations and an independent check.

02 / OBSERVEBring fresh context

Goal, state, admitted evidence and action history guide the next decision.

03 / CHOOSE + ACTJev chooses; code acts

Select registered tools and current candidates. Bind, check and execute real values.

04 / CHECK + LOOPContinue or return evidence

Verify the outcome. Repeat with new observations, or finish, block or request review.

03 / A REUSABLE TOOL FOUNDATION

New task.
Same loop.

Your AI adds capabilities in a task script. Business-specific rules stay in those tools; the runtime manages the loop.

Read the tool contract ↗

{ }

Candidates can appear later

Dynamic domains come from new observations. Dependent parameters resolve in order.

↳

Each result informs the next step

Admit result summaries and action history; task tools can read retained evidence.

An interface your AI can use

Machine-readable spec, script scaffold, static checks and a bundled skill.

◎

Completion comes with evidence

Independent checks, action history and model-usage records in one ledger.

04 / THE EXECUTION LOOP IN ACTION

See the loop
inside a browser.

A historical four-step browser fixture connects observation, Jev selection, execution and independent result checks.

travel-request / local fixtureSCREENSHOT REPLAY

Screenshot replay of the local browser fixture. Follow the evidence link to inspect the Jev acceptance record.

v0.1.0 / HISTORICAL LIVE ACCEPTANCE

A four-step browser task.
Independently checked.

Real Jev + headless Camofox filled traveler and destination, set flexible dates and prepared a draft. The verifier checked field values and final DOM text.

OBSERVED RESULT: Draft ready: Mira | London | flexible=true
SCOPE: 4 tool executions in a local synthetic travel-draft fixture.

Inspect the historical evidence ↗

↗

BUILD YOUR OWN TOOLCHAIN

Add capabilities. Reuse the loop.

Define tools around your workflow, return meaningful candidates from fresh observations, and give every task a completion check. The same runtime connects them into a Jev agent loop.

Read the evidence ↗

05 / GIVE YOUR AI THE CONTRACT

Define the goal.
Let AI build the script.

Use the bundled skill and task protocol. Ask your AI to define trusted tools, fresh candidate providers and an independent artifact check, then hand the task to the loop.

Installation & task protocol ↗spec.json ↗

Start with the runnable counter scaffold below, then add tools and checks for your open task. Run trusted Python scripts with your own inference credentials.

terminal / smoke scaffold

# Create a virtual environment
python -m venv .venv
. .venv/bin/activate

# Install the pinned version
pip install 'git+https://github.com/apixly-ai/jev-harness.git@v0.1.17'

jev-harness spec
jev-harness init-task task.py
jev-harness check-task task.py
# Configure TYPESAFE_API_KEY in your environment
jev-harness run task.py \
  --goal "Reach target" --inputs '{"target":3}'

06 / FIND YOUR ANSWER

Understand the contract.
Inspect the evidence.

How does AI hand off an open task? ↗Script ownership, dynamic candidates, generated content and task contracts.Which cases show the core idea? ↗Open research, repository diagnosis and controlled API investigation: goals, tools and output contracts.

Give AI a goal.Let Jev findthe next step.

Write the tools.Discover the path.

Start with a question.Find the useful sources.

Follow the failure.Find the cause.

Follow the response.Map the dependencies.

One task contract.Many possible routes.

New task.Same loop.