Auto, Training Mode

Open A Training Session

  1. Open the company and select Train.
  2. Choose a task or completed run to use as training material.
  3. Review the source steps and the proposed reusable procedure.
  4. Accept the bundle only after its sources and instructions are correct.

Company training workspace with source material and training status

Training mode is the company dashboard surface for rehearsing one real task until it becomes reliable enough to trust live.

This guide explains what training mode does, what Neotask creates during training, and how to train a task efficiently without fighting the system.

What Training Mode Is

The Train tab is not a generic chatbot and it is not a throwaway sandbox.

It is a guided rehearsal lane for one specific company task.

That means a training session is always tied to:

Training mode exists so you can:

The goal is not to “train the model.” The goal is to train the task’s reusable operating guidance.

Where To Find It

Open Auto, open a company, then click Train in the company tab bar.

The Train tab automatically loads the company’s current task list. You do not create a separate training-only task list.

That matters because training is supposed to improve the same real tasks that later run live.

What A Fresh Training Session Looks Like

A true first-time training session starts with no accepted bundle and no staged bundle for that task.

The flow should feel like this:

  1. open a real task in Train
  2. answer a short preflight
  3. run the baseline once
  4. answer any meaningful checkpoints during the run
  5. coach the task in the training input
  6. click Add to Training
  7. review the generated changes
  8. click Bundle It
  9. run Train Again until the result becomes consistent

You should not see a pile of training files before the first training pass has actually created them.

What The Main Training Surfaces Mean

The training workspace is built around three operator jobs:

Activity Feed

This is where you watch the task operate.

Use it to understand:

Training Input

This is where you coach the task.

Use it to tell the task:

Bundle Review

This is where you review the training artifacts that Neotask generated from the run and your guidance.

This is the critical trust surface because it shows:

The Three Main Training Phases

Preflight

Before the first meaningful run, Neotask asks short setup questions.

Use preflight to define:

Good preflight answers make the first run much closer to correct.

Checkpointed Execution

During the run, Neotask can pause at meaningful action boundaries.

That means it may stop to ask about:

It should not pause for every tiny click.

The right mental model is:

Post-Run Consolidation

After the run, you review what training generated.

This is where Add to Training and Bundle It matter.

That final review is mandatory because the system is supposed to show you the exact guidance it wants to keep.

What Add To Training Does

Add to Training stages a working bundle for that task.

That working bundle is the system’s current proposal for how the task should improve.

It is not fully trusted yet. It is the staged version you review before accepting it.

After you click Add to Training, you should expect to see:

What Bundle It Does

Bundle It promotes the current working bundle into the accepted bundle.

That accepted bundle becomes the task’s active training guidance for:

This is the point where training stops being a draft and starts becoming durable task behavior.

What Files Training Creates

Training mode works by creating reusable guidance files for the task.

The exact file set can grow over time, but the core training bundle typically includes these kinds of files:

Routine

The routine is the task’s operating playbook.

It usually captures:

Output Template

The output template defines what the finished answer should look like.

This is where Neotask can lock in things like:

QA Checklist

The QA checklist is the “before returning this result, verify these things” layer.

This is useful for making a task reliably check itself before it finishes.

Typical examples:

Placeholders

Placeholder files tell the task what to do when real data is missing.

This prevents the task from making up details just to complete the shape.

Examples include placeholder tokens for:

Additional Guidance Files

Depending on the task, Neotask can also create or evolve other bundle files later.

Examples include:

The important operator rule is simple:

you are reviewing reusable task guidance, not just one answer transcript.

Where This Information Comes From

This is the point that most users need clarified at least once:

the long training documents you see are usually not something the user typed by hand.

They come from a combination of:

So if you open a trained task and see a long routine or checklist, that does not mean someone manually authored every line in the training pane. It means training has already materialized those instructions into task files.

Working vs Accepted Bundles

Training mode keeps two bundle states separate on purpose.

Working Bundle

The working bundle is the currently staged proposal.

Think of it as:

Accepted Bundle

The accepted bundle is the currently trusted task guidance.

Think of it as:

If you are not sure what changed recently, compare working against accepted before bundling.

How Training Improves The Next Run

Training improves a task because the accepted bundle is loaded again on the next run.

That means the next training run does not start from zero. It starts with the accepted routine, template, checklist, placeholders, and other task-linked guidance already attached to that task.

That is why a good training loop should look like:

If a task keeps behaving exactly like the baseline after bundling, training is not actually being applied correctly.

What Is Simulated In Training

Training mode is supposed to be a rehearsal lane.

That means the task can still surface:

But the user experience should still feel like review and guidance first, not uncontrolled live execution.

The operator should be able to see:

before trusting the task live.

The Best Way To Train A Task

The best training runs start from a task that is slightly vague but has a clear business outcome.

Good examples:

This is the recommended training pattern:

  1. define the desired business outcome clearly
  2. answer preflight in concrete terms
  3. let the first run happen without overcorrecting too early
  4. fix the biggest structural mistakes first
  5. stage the bundle
  6. review the files and diffs
  7. bundle only when the guidance looks durable
  8. rerun several times to verify consistency

Do not judge training by whether one lucky run looked good. Judge it by whether repeated reruns keep producing the right structure and decisions.

Best Practices

What To Avoid

How To Tell Training Is Working

You should see this pattern:

  1. the first run is incomplete, weak, or inconsistent
  2. your guidance creates a meaningful working bundle
  3. the files and diffs reflect the improvements you actually asked for
  4. the accepted bundle becomes the new baseline
  5. repeated reruns stay in the improved shape

That is the strongest sign that the task is truly learning the right behavior at the task level.

How Training Relates To The Rest Of Auto

Training mode is not separate from the rest of the company dashboard. It works with the same company context.

Training is closely related to:

Use training when the task exists but is not trustworthy enough yet. Use the live task lane only after training proves the task is stable.