- Brand
- Cigo Tracker
- Category
- Operations
- Primary Subcategory
- Freight & Logistics Operations
Integration details
Description
Cigo Foresight connects ChatGPT to your Cigo Tracker account. Sign in with your Cigo login and ask about jobs, routes, drivers, invoices and delivery performance in plain language. ChatGPT reads Foresight's reporting tables with one SQL SELECT at a time, and the Cigo Dispatch API record by record, always limited to the providers your login belongs to and, for a merchant, only its own locations. If you allow writes when you sign in, ChatGPT can also create, update, cancel and delete Dispatch records. Changes take effect immediately in your Cigo account. You need a Cigo Tracker account with Foresight enabled.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Freight & Logistics Operations
- Secondary Subcategories
- None listed
- Brand
- Cigo Tracker
- Access
- Account required
- First tracked
- 2026-11-14
- Tool count
- 32
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Cigo Foresight suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Cigo Foresight
Get updates when Cigo Foresight’s Discoverability Score or category rank changes.
Competing in ChatGPT Freight & Logistics Operations
View Category32 tools agents can invoke
Cancel jobs of the user's linked Dispatch account, 1 to 50 a call. It sends POST /jobs/id/{jobID}/cancel once for each ID of `job_ids`. `job_ids` are job IDs a read returned, each once. A cancel sets the job's status to cancelled and triggers Dispatch's cancellation workflows; only a supervisor sub-user may cancel. A cancelled job cannot be deleted afterwards: Dispatch answers 403 to its delete. To make a job go away, delete it instead of cancelling it. Each cancel is made at once with no undo: cancel only what the user asked for. One job answers as Dispatch did, with `read_back`. Several answer `results` in the order of `job_ids`, each with its `ok`, `status_code` and `read_back`; a result's place in `results` is its job's in `job_ids`, except one skipped after the call stopped, which names its `entry`. With `stop_at_first_failure` the first job not cancelled ends the call and skips the rest. The jobs not sent, after 30 seconds, when the answer is full or when the account's turn or minute refuses one, are `left` with `why_left`, to pass again as `job_ids`. `ok` is true when every cancel was accepted.
dispatch_cancel_jobs
How far an export of concluded_jobs_report got: `status` waiting, reading, done or failed with `error`, `rows_written` of `rows_counted`, and its `download` link. An export is kept 7 days.
export_status
Check what the user's linked Dispatch account can still book, by one of these. `slots`, with a `date` as YYYY-MM-DD and a `geolocation` as latitude,longitude: the jobs, weight and volume that day can still take there (GET /available-slots). `booking_dates`, with a `geolocation` or an `address` and the job's weight, volume or handle time when they matter: the days a job can be booked (GET /available-booking-dates). Dispatch answers 403 when the account does not have them enabled. `fields` keeps only the keys it names, `offset` and `limit` return part of each list with `lists` giving each list's total, and an answer over 40,000 characters is refused with what to pass instead. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): GET /available-slots: max_jobs, available_jobs_slots, max_weight, available_weight_slots, max_volume, available_volume_slots. GET /available-booking-dates: available_booking_dates. A name in fields is one of these.
dispatch_check_availability
Copy jobs of the user's linked Dispatch account to another date, as Foresight's own chat copies them. It reads each job with GET /jobs/id/{jobID} and creates its copy with POST /jobs. `job_ids` are 1 to 50 job IDs a read returned, each once, and `date` is the copies' day as YYYY-MM-DD. Each job is read first, and nothing is sent while one cannot be read. A pickup or a dropoff Cigo generated is left out, under `generated_stops`: Cigo generates it again when the copy is routed. Each copy is built from the job as the create takes it, with the fields the contract accepts, the job's actions, out of staging and without the reference the create generates, and checked against the contract; a copy it would refuse is under `not_copied` with the reason and is not sent. The copies that pass are created one after another, as the account's writes are, each at once and with no undo. `created` has each source with its name, the `new_id` Dispatch gave the copy and its `read_back`, as dispatch_create_jobs answers one: `verified` when the copy reads back, `mismatch` with what was `found`, or `unread` when Dispatch did not answer the read in time; `refused` the copies Dispatch refused and `unknown` those it did not answer, which it may have made. The reads take up to 30 seconds and the copies 30 more, about ten to fifteen copies at the demo's latency: the copies not sent by then, or after the account's turn or minute refused one, are `left` with `why_left`: call again with `call_again_with`, exactly as it is, which keeps `date`. `ok` is true when every copy sent was accepted.
dispatch_copy_jobs
Create a route, an itinerary, in the user's linked Dispatch account: one a call. It sends POST /itineraries. `route` is the route as the contract declares it, with its day, start, vehicle and the jobs it takes as `add_ids`; a job on a route takes only some changes and cannot be deleted. A sub-user may not create a route. The route is made at once with no undo: create only what the user asked for. The answer is Dispatch's, with the new `itinerary_id`, and `read_back` says whether the route reads back holding its jobs.
dispatch_create_route
Create jobs in the user's linked Dispatch account, 1 to 50 a call, as an import makes them. It sends POST /jobs once for each job of `jobs`. Each entry of `jobs` is one job as the contract declares it, with its actions; two equal entries make two jobs. A job goes to staging, the Import Tool, for a dispatcher to review unless it sets `skip_staging`, and a sub-user must pass `branch_id` and `distribution_center_id`. Creating a job also creates a customer from the job's contact fields when the account has none that matches them; the customer stays when the job is deleted. A job with an `email` or a `mobile_number` may be notified to its customer by Email and SMS, even on the demo. Every job is checked against the contract before the first leaves; one it would refuse refuses the call with its number. Each is created at once with no undo: create only what the user asked for. One job answers as Dispatch did: `data` with the new `job_id`, and `read_back`. Several answer `results` in the order of `jobs`, each with its `ok`, `status_code`, `read_back` and the `ids` Dispatch named; a result's place in `results` is its job's in `jobs`, except one skipped after the call stopped, which names its `entry`. With `stop_at_first_failure` the first job not accepted ends the call and skips the rest. The jobs not sent, after 30 seconds, when the answer is full or when the account's turn or minute refuses one, are `left` with `why_left`, to pass again as `jobs`. With `outcome_unknown` Dispatch may have made the job: search for it before creating it again. `ok` is true when every job was accepted.
dispatch_create_jobs
Delete one route, an itinerary, of the user's linked Dispatch account, while it has not started yet. It sends DELETE /itineraries/id/{itineraryID}. A sub-user may not delete one. A delete has no undo: delete only what the user asked for. The answer is Dispatch's, and `read_back` is `verified` once the route reads as gone.
dispatch_delete_route
Delete jobs of the user's linked Dispatch account, 1 to 50 a call, or their actions. It sends DELETE /jobs/id/{jobID} once for each ID, DELETE /jobs/id/{jobID}/actions once for each ID with `all_actions`, or DELETE /jobs/id/{jobID}/actions/{actionID} with `action_id`. `job_ids` are job IDs a read returned, each once. Alone, each job is deleted; with `all_actions`, each job's actions are and the job stays; with `action_id`, that one action of the one job in `job_ids`. Dispatch deletes a job only while it is in staging or pending and on no route, and a sub-user only the jobs it created. A cancelled job cannot be deleted: Dispatch answers 403 to the delete of a job once it is cancelled, and the job stays as cancelled. A job on a route keeps its pickup, return and exchange actions, and a fulfilled job keeps all of its actions. A delete has no undo: delete only what the user asked for. One delete answers as Dispatch did, with `read_back`, `verified` once the record reads as gone. Several answer `results` in the order of `job_ids`, each with its `ok`, `status_code` and `read_back`; a result's place in `results` is its job's in `job_ids`, except one skipped after the call stopped, which names its `entry`. With `stop_at_first_failure` the first not accepted ends the call and skips the rest. The jobs not sent, after 30 seconds, when the answer is full or when the account's turn or minute refuses one, are `left` with `why_left`: call again with `call_again_with`, exactly as it is, which keeps `all_actions`. `ok` is true when every delete was accepted.
dispatch_delete_jobs
Delete break windows of one vehicle of the user's linked Dispatch account: 1 to 50 a call. It sends DELETE /vehicles/id/{vehicleID}/breaks/{breakID} once for each ID of `break_ids`, or with `itinerary_id` DELETE /itineraries/id/{itineraryID}/vehicles/id/{vehicleID}/breaks/{breakID}. Pass the `vehicle_id` and its `break_ids`, each once. With `itinerary_id`, each break comes off that route only and the vehicle keeps it. A sub-user may not delete a vehicle's breaks. A delete has no undo: delete only what the user asked for. One delete answers as Dispatch did. Several answer `results` in the order of `break_ids`, each with its `ok` and `status_code`; a result's place in `results` is its break's in `break_ids`, except one skipped after the call stopped, which names its `entry`. With `stop_at_first_failure` the first not accepted ends the call and skips the rest. The breaks not sent, after 30 seconds, when the answer is full or when the account's turn or minute refuses one, are `left` with `why_left`: call again with `call_again_with`, exactly as it is, which keeps `itinerary_id`. `ok` is true when every delete was accepted.
dispatch_delete_vehicle_breaks
Create a CSV file of the Concluded Jobs report (Order Management → Concluded Jobs → Export) of the signed-in Cigo user's providers, and a link that downloads it, for the page's filters; no Cigo record changes. The file has no action details, and the server writes the SQL and the file, of any size. Action details are temporarily unavailable in this report; we're working on it. If asked for them, say so and offer the report without them. include_actions must be false. start_date and end_date are the Date Range on the scheduled date, both included, at most 400 days apart. Empty filters restrict nothing, as on the page; locations are reference numbers or names, exactly; search matches any of up to 5 words. Answers {"ok": true, "export_id", "status", "rows_counted", "rows_written", "download"}, or {"ok": false, "error"} naming the argument to correct. Give the user the `download` link: it opens after their Cigo sign-in and downloads the file once it is whole, which a large report takes minutes to be. `status` is waiting, reading, done or failed, with `error`; export_status tells how far it got. `left_out` names days the file lacks.
concluded_jobs_report
List Cigo Foresight's reference files, each with its `path`, `lines` and `characters`. They are what Cigo's words and metrics mean, its reporting tables and how they join, its reports and the click paths of its screens (`knowledge/foresight/`, which `index.md` there lists by subject); the tables and columns of the reporting data and Dispatch's API contract (`contracts/`); and notes on Dispatch's API (`.agents/skills/cigo-dispatch/references/`). `under` keeps one folder, such as `knowledge/foresight/policies`. Read a file with workspace_read, and find text in the files with workspace_search.
workspace_list
Preview a route of the user's linked Dispatch account without saving it: its stops in the order Dispatch would route them, its metrics and its warnings (POST /itineraries/action/previewRoute). Nothing is created or changed. `route` has the `date`, `start_time`, `vehicle_id`, `start_point` and `end_point`, and the `job_ids` or `stops` to route, as its schema says. `fields` keeps only the keys it names, `offset` and `limit` return part of each list, and an answer over 40,000 characters is refused with what to pass instead. Dispatch answers 403 when the account does not have route previews enabled. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): POST /itineraries/action/previewRoute: itinerary{itinerary_id, date, time, time_frame_size, start_location, end_location, route_status_code, route_error_message, round_trip, route_metrics, route_options, vehicle, operators, stops_count, stops, warnings}. A name in fields is one of these, or one key below it and no deeper.
dispatch_preview_route
Read one of Cigo Foresight's reference files by its `path` from the top, as workspace_list writes it: `knowledge/foresight/index.md`. A link inside a file is relative to that file's folder. The text comes in whole lines from `line`, 1 the first, and `limit` is how many. An answer holds 40,000 characters: `lines` says the file's total, the first line returned and how many came, and when the file goes on, `note` gives the `line` to call again with. The files describe Cigo's data and screens, and were written for Foresight AI, the assistant inside Cigo's own application. Where one speaks of that assistant's page, such as a table cut at 25 rows, Download CSV or a link like `/job/<id>`, or names its `AGENTS.md` or a skill, it means Cigo's application: this server has no such page and serves neither file.
workspace_read
The invoice data on the jobs scheduled in a period of the user's linked Dispatch account: each job's `invoices`, and each of its actions' `invoice_number`, `value` and `quantity`. The dates are YYYY-MM-DD, the days the jobs are to be fulfilled, and Dispatch searches at most 30 days from start_date to end_date, so July 1 to July 31 is one call and a quarter is three. A call searches the period and reads up to 50 of its jobs, and may take 30 seconds. `ok` is true when the call read. `period_jobs` is how many jobs the period has and `jobs` the ones this call read, each with its `job_id`, `date`, `invoices` and `actions`, and each action with its `invoice_number`, `value` and `quantity`. `totals_so_far` counts every job read since the first call: `jobs`, `jobs_with_invoice` (those with a number in `invoices`), `actions`, `actions_with_invoice` (those with an `invoice_number`) and `value`, the sum of the actions' `value`. `reads` counts the call's reads of Dispatch. While the answer has `next`, call again with the same dates and `cursor` set to it, after `retry_after_seconds` when that is there; `wait` says why to wait. With no `next` and `totals_so_far.jobs` equal to `period_jobs`, every job was read. `not_read` has the jobs Dispatch refused or did not answer in two calls, each with its `job_id`, `status_code` and `error`: they are in no total, so say which are missing. Dispatch has no date and no total of an invoice, and does not say whether `value` is a unit price or a line amount.
dispatch_invoices
Read customers of the user's linked Dispatch account: one by `customer_id` (GET /customers/id/{customerID}), or with `search` the first 20 that match a name, which may be partial, a phone or mobile number, an email, an invoice or a reference (POST /customers/search). Pass one of the two. `fields` keeps only the keys it names, `offset` and `limit` return part of each list with `lists` giving each list's total, and an answer over 40,000 characters is refused with what to pass instead. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): GET /customers/id/{customerID}: customer{customer_id, full_name, phone_number, mobile_number, address, coordinates, reference_id, defaults, jobs}. POST /customers/search: customers[customer_id, full_name, reference_id, phone_number, mobile_number, email]. A name in fields is one of these, or one key below it and no deeper.
dispatch_get_customers
Read the drivers, Dispatch's operators, of the user's linked Dispatch account: all of them without `operator_id` (GET /operators), or one with it (GET /operators/id/{operatorID}). `fields` keeps only the keys it names, `operators.name` of each operator, `offset` and `limit` return part of each list with `lists` giving each list's total, and an answer over 40,000 characters is refused with what to pass instead. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): GET /operators: operators[id, name, reference_id, username, phone_number, language, timezone, last_active, avg_rate, activated]. GET /operators/id/{operatorID}: operator{as operators}. A name in fields is one of these, or one key below it and no deeper.
dispatch_get_drivers
Read 1 to 50 jobs of the user's linked Dispatch account by ID, one part of each. `part` is `job`, the job with its actions and the stops related to it on its route (GET /jobs/id/{jobID}); `reports`, its signatures, fulfillment, incidents and what was left incomplete (GET /jobs/id/{jobID}/reports); `chat`, its chat messages (GET /jobs/id/{jobID}/chat), or with `message_id`, which a message's create answered, that one message of one job with whether it was read (GET /jobs/id/{jobID}/chat/{messageID}); `location`, where its operator is while the job is in progress (GET /jobs/id/{jobID}/location), with the ETA and distance when `route_data` is true; or `geofencing`, its geofence entries and exits (GET /geofencing/job_id/{job_id}). For one ID the answer is the read's `data`, with `lists` giving the total of each list in it, such as the job's actions, which `offset` and `limit` cut. For more, `results` has one result for each job read, in the order given, with its `job_id`, its own `ok` and its own `data` and `lists`: one that Dispatch refused does not undo the others. `left` has the IDs still to read: send `call_again_with`, exactly as it is, after `retry_after_seconds` when it is there. Pass `fields`, such as ["job.status", "job.date", "actions.invoice_number"], so that all of them fit: it keeps only the keys it names; a name the part never answers is refused, or named in `fields_not_found`, with the keys it has. `reports.incomplete.reason_approved` is true by default: a report not `submitted`, with no `message`, holds no reason to accept. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): job: job{}, actions[], related_on_route_stops[]. reports: reports{}. chat: chat[]. chat with message_id: message_id, job_id, message, sent_on, is_read. location: job{}. geofencing: geofence_events[], first_geofence_entry, last_geofence_exit, timezone*. A name in fields is one of these, or one key below it and no deeper.
dispatch_get_jobs
Read the saved locations of the user's linked Dispatch account, its depots and other places: all of them without `location_id` (GET /locations), or one with it (GET /locations/id/{locationID}). `fields` keeps only the keys it names, `offset` and `limit` return part of each list with `lists` giving each list's total, and an answer over 40,000 characters is refused with what to pass instead. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): GET /locations: locations[id, type, name, reference_id, address, postal_code, coordinates, activated]. GET /locations/id/{locationID}: location{as locations}. A name in fields is one of these, or one key below it and no deeper.
dispatch_get_locations
Read the routes, Dispatch's itineraries, of the user's linked Dispatch account by one of these. `dates`, the routes of 1 to 50 days as YYYY-MM-DD (GET /itineraries/date/{date}). `itinerary_ids`, 1 to 50 routes by ID (GET /itineraries/id/{itineraryID}), or with `polyline` true the path each one drives, as GeoJSON (GET /itineraries/id/{itineraryID}/polyline). `operator_id` or `vehicle_id`, the routes of an operator or a vehicle (GET /itineraries/operator/{operator}, GET /itineraries/vehicle/{vehicle}) from `start_date` to `end_date`, at most 30 days apart, or of the last 7 days without them. For several `dates` or `itinerary_ids`, `results` has one result for each day or route read, with its `date` or `itinerary_id` and its own `ok`, and `left` the days or IDs still to read: call again with `call_again_with`, exactly as it is, after `retry_after_seconds` when it is there. `fields` keeps only the keys it names, `itineraries.stops` of each route among them, `offset` and `limit` return part of each list with `lists` giving each list's total, in the answer for one day or route and in each result for several, and an answer over 40,000 characters is refused with what to pass instead. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): GET /itineraries/date/{date}: date, itineraries[itinerary_id, numeric_id, date, planned_departure_datetime, time, time_frame_size, start_location, end_location, route_status_code, route_error_message, round_trip, route_metrics, route_options, vehicle, operators, stops_count, stops, options]. GET /itineraries/id/{itineraryID}: itinerary{as itineraries}. GET /itineraries/id/{itineraryID}/polyline: geojson{type, coordinates}. GET /itineraries/operator/{operator} and GET /itineraries/vehicle/{vehicle}: date{start_date, end_date}, itineraries[as above]. A name in fields is one of these, or one key below it and no deeper.
dispatch_get_routes
Read the signed-in Cigo user's provider profile, as Foresight's own chat reads it: the provider's usual job areas, its recent operators and fleet, and the dates they were observed over. It is background evidence, not the account's current state. `provider_id` is needed only when the user has more than one provider; another provider's profile is never returned.
provider_profile
Read the vehicles of the user's linked Dispatch account: all of them without `vehicle_id` (GET /vehicles), one with it (GET /vehicles/id/{vehicleID}), or with `breaks` true the breaks configured on that one (GET /vehicles/id/{vehicleID}/breaks). `fields` keeps only the keys it names, `vehicles.name` of each vehicle, `offset` and `limit` return part of each list with `lists` giving each list's total, and an answer over 40,000 characters is refused with what to pass instead. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): GET /vehicles: vehicles[id, name, reference_id, type, weight_capacity, volume_capacity, license_plate, start_time, start_location, end_location, activated, breaks]. GET /vehicles/id/{vehicleID}: vehicle{as vehicles}. GET /vehicles/id/{vehicleID}/breaks: breaks[break_api_id, vehicle_api_id, window_start, window_end, break_timing, duration, created_at]. A name in fields is one of these, or one key below it and no deeper.
dispatch_get_vehicles
Run one MySQL SELECT over Foresight's reporting tables as the signed-in Cigo user, and return its rows as JSON objects. The tables and columns are the ones contracts/sql/reporting-schema.txt declares: read it with workspace_read. What a word of the business or a metric means in these tables, such as which jobs "deliveries" or "completed" count and which date column a period uses, is defined in the pages knowledge/foresight/index.md lists: workspace_search finds a word in them. A row's `api_id` is the ID the Dispatch tools take, and its `id` the number on its page in Cigo: `tbl_package` for a job, `tbl_schedule` for a route. Every table is read through the user's providers, and a merchant's through its locations, as Foresight's own chat reads; another provider's rows are never returned. A job still in staging, the Import Tool, may be missing from these tables: a count or list of jobs that should include them adds what dispatch_search_jobs answers under `in_staging` when this connection lists that tool, and otherwise says those jobs may be missing; the answer says which jobs it counts. One statement, no lock, variable or file; a refused one is answered with the reason. `rows` is how many to return, 200 unless you pass it and at most 1,000, within an answer of 40,000 characters. `truncated` says when the rows are not the whole result: aggregate in SQL, or page with ORDER BY, LIMIT and OFFSET. A user makes 60 SQL reads a minute.
sql_read
Take jobs or drivers off one route, an itinerary, of the user's linked Dispatch account: 1 to 50 a call. It sends DELETE /itineraries/id/{itineraryID}/job_id/{jobID} once for each ID of `job_ids`, or DELETE /itineraries/id/{itineraryID}/action/unassignOperators/operator_ids/{operatorID} once for each ID of `operator_ids`. Pass the route's `itinerary_id` and one of `job_ids`, the jobs to take off it, or `operator_ids`, the drivers to unassign, each once. A job comes off only while its stop has not started, and a pickup or dropoff stop comes off only with all of its related jobs. Dispatch deletes a route its last stop leaves. A removal has no undo: remove only what the user asked for. One removal answers as Dispatch did, with `read_back`, `verified` once the route reads back without the job. Several answer `results` in the order passed, each with its `ok`, `status_code` and `read_back`; a result's place in `results` is its ID's in the list, except one skipped after the call stopped, which names its `entry`. The removals go one after another, and those after one whose outcome is unknown are skipped. With `stop_at_first_failure` the first not accepted ends the call and skips the rest. The IDs not sent, after 30 seconds, when the answer is full or when the account's turn or minute refuses one, are `left` with `why_left`: call again with `call_again_with`, exactly as it is, which names the route and the list. `ok` is true when every removal was accepted.
dispatch_remove_from_route
Match the words the user used for an area, such as "usual Laval area" or "the north shore", to the areas of the signed-in user's provider profile, as Foresight's own chat does. `status` says how it matched, and `matches` has each area with its center, radius in km and observed dates; none matched is `ok: false`. `provider_id` is needed only when the user has more than one provider.
resolve_area
Create a location, such as a depot, in the user's linked Dispatch account, or change one: one a call. It sends POST /locations for `new_location`, or PATCH /locations/id/{locationID} for `location_id` and `changes`. Pass `new_location`, a location as the contract declares it, or `location_id` and `changes`, the changes to that location; `active` false takes it out of use. A sub-user may not create or change one. The change is made at once with no undo: change only what the user asked for. The answer is Dispatch's, with the new `location_id` after a create, and `read_back` says whether it reads back as sent.
dispatch_save_location
Add a break window to a vehicle of the user's linked Dispatch account, or change one: one break a call. It sends POST /vehicles/id/{vehicleID}/breaks for `new_break`, or PATCH /vehicles/id/{vehicleID}/breaks/{breakID} for `break_id` and `break_changes`. Pass the `vehicle_id` and one of `new_break`, a break as the contract declares it, or `break_id` and `break_changes`, the changes to one of its breaks. A vehicle has up to 3 break windows, and a sub-user may not change them; an account whose plan has no breaks is answered 403. The change is made at once with no undo: change only what the user asked for. The answer is Dispatch's, with the new break's ID after an add.
dispatch_save_vehicle_breaks
Find text in Cigo Foresight's reference files: every line that holds `query` as written, in any case. It is not a pattern: search the words of the question or a name, such as "handle time" or "tbl_schedule", in at most 300 characters. The files say what a word or a metric means in Cigo's data, such as which jobs "deliveries" count and which date a period uses (`knowledge/foresight/`); what a table or a column holds (`contracts/sql/reporting-schema.txt`); what a key of a Dispatch answer means (`contracts/cigo-swagger.json`); and how a task is done on Cigo's screens (`knowledge/foresight/ui/`, click paths performed on the real application: a task with no steps there has no documented path). Each match has its `path`, its `line` and the line's `text`, cut around the match when the line is long. `under` keeps one folder or one file. `found` counts the lines and the files that matched and the lines returned. When they do not all fit in an answer, `files` counts the matches of each file: pass one as `under`, or read it with workspace_read.
workspace_search
Search the jobs of the user's linked Dispatch account by date and other criteria, 1 to 50 searches in a call: POST /jobs/search for each. Each search has `start_date` as YYYY-MM-DD, an `end_date` at most 30 days after it, and the criteria its schema lists, such as `status`, `invoice_number` or `on_itinerary`; a longer period is several searches in one call, of 30 days or less each. Dispatch answers the jobs' IDs alone, in `in_staging.ids` and `post_staging.ids`: read the jobs with dispatch_get_jobs, up to 50 a call. For one search the answer is the read's `data`. For more, `results` has one result for each search made, in the order given, with its `search` and its own `ok`, and `left` the searches still to make, as they were passed: pass them again, after `retry_after_seconds` when it is there. Many IDs are read in parts with `fields` ["in_staging.ids", "post_staging.ids"] and `offset` and `limit`; `lists` gives each list's total, in the answer for one search and in each search's result for more. An answer over 40,000 characters is refused with what to pass instead. An account reads 600 times a minute, 4 at once; a call past that says when to call again. Keys of the answer, names only, none sure to be there, statusCode and status left out ([ ] a list's records' keys, { } an object's, * not in the contract): POST /jobs/search: in_staging{count, ids}, post_staging{as in_staging}. A name in fields is one of these, or one key below it and no deeper.
dispatch_search_jobs
Write a message in a job's Notes and Chat, in the user's linked Dispatch account, or edit one: one a call. It sends POST /jobs/id/{jobID}/chat for `new_message`, or PUT /jobs/id/{jobID}/chat/{messageID} for `message_id` and `edited_message`. Pass the `job_id` and one of `new_message`, or `message_id` and `edited_message`, the message's new text. Only a message created through the API can be edited, and an edited message shows as unread and notifies the job's operators. A message is sent at once with no undo: write only what the user asked for. The answer is Dispatch's; no read judges a message, so `read_back` is `not_covered`.
dispatch_send_job_message
Change a driver, an operator, of the user's linked Dispatch account: one a call. It sends PATCH /operators/id/{operatorID}. Pass the `operator_id` and `changes`, the fields to change as the contract declares them; `active` false blocks the driver's access. A driver's login, `email` and `password`, is changed in the Cigo dashboard and refused here. A driver is created in the Cigo dashboard, which sets their login (email and password); this server cannot create one. A sub-user may not change a driver. The change is made at once with no undo: change only what the user asked for. The answer is Dispatch's, and `read_back` says whether the driver reads back as sent.
dispatch_update_driver
Change one route, an itinerary, of the user's linked Dispatch account: one change a call. It sends PATCH /itineraries/id/{itineraryID} for `changes`, PATCH /itineraries/id/{itineraryID}/action/updateOperators for `crew`, PATCH /itineraries/id/{itineraryID}/action/updatePositions for `stop_order`, PATCH /itineraries/id/{itineraryID}/action/reversePositions for `reverse`, or PATCH /itineraries/id/{itineraryID}/job_id/{jobID}/position/{position} for `job_id` and `position`. Pass the route's `itinerary_id` and one of: `changes`, its fields and the jobs it adds as `add_ids`; `crew`, its drivers, which replace those it has, at most 4 unless the account allows more; `stop_order`, its stops in their new order; `reverse` true, its stops in reverse; or `job_id` and `position`, one stop moved to that position. A route takes changes only while it is not completed, and a sub-user may not change one. `changes` takes no `delete_ids`: Dispatch deletes a route that taking jobs off empties, so jobs come off a route with dispatch_remove_from_route. Each change is made at once with no undo: change only what the user asked for. The answer is Dispatch's, with its `warnings`, such as jobs it did not add. `read_back` is `verified` when the route reads back holding the jobs added or the crew sent, and `not_covered` for other fields, an order or a position, which no read judges.
dispatch_update_route
Update jobs of the user's linked Dispatch account, or add or edit one job's action. It sends PATCH /jobs/id/{jobID} once for each entry of `updates`, POST /jobs/id/{jobID}/actions for `new_action`, or PATCH /jobs/id/{jobID}/actions/{actionID} for `action_changes`. Pass one of: `updates`, 1 to 50 entries, each a `job_id` a read returned and the `changes` to make to that job, as the contract declares them; `job_id` and `new_action`, an action to add to that job; or `job_id`, `action_id` and `action_changes`, the changes to one of its actions. A job on a route whose `state` is `new` takes changes only to `quick_desc`, its contact fields, `apartment`, `time_preference`, `invoices` and `balance_owed`. A job on a route takes no new pick up, return or exchange action, and a fulfilled job or action takes no action change. A job with an `email` or a `mobile_number` may be notified to its customer by Email and SMS. Each change is made at once with no undo: send only what the user asked for. One change answers as Dispatch did, with `read_back`. Several `updates` answer `results` in their order, each with its `ok`, `status_code`, `read_back` and the `ids` Dispatch named; a result's place in `results` is its entry's in `updates`, except one skipped after the call stopped, which names its `entry`. Two entries for one job go in order, and one after an entry for the same job whose outcome is unknown is skipped. With `stop_at_first_failure` the first not accepted ends the call and skips the rest. The entries not sent, after 30 seconds, when the answer is full or when the account's turn or minute refuses one, are `left` with `why_left`, to pass again as `updates`. `ok` is true when every change was accepted.
dispatch_update_jobs
Cigo Foresight ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Cigo Foresight's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Cigo Foresight alternatives on ChatGPT?
As of 2026-11-15, Cigo Foresight competes with 3DPACK.ING, 4truck, AfricaCTN ECTN Guide, ATICA-SICE, bryny, Cambridge China Bridge, Conterminal Shipments, Damoov Telematics and 34 more in ChatGPT Freight & Logistics Operations, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.


