> For the complete documentation index, see [llms.txt](https://docs.concurrence.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.concurrence.com/agent/reasoning-engine.md).

# Reasoning Engine

How agent guidance, Context Graphs, tools, and channel controls coordinate reasoning, ongoing work, and responses across supported interactions.

The reasoning engine combines an agent's guidance, a Context Graph's problem definition, and available evidence to decide what to do next. Supported state-machine paths can navigate a workflow, invoke tools, use their results, and continue without requiring another user message. Voice, text, and simulation reuse definitions and selected reasoning components, while their execution, delivery, and connection lifecycles differ.

Reasoning is part of the Agent Engine's wider responsibility: receiving input, coordinating ongoing work, and controlling what reaches the user or an external system. Generating a reply, playing it, and completing an external action are separate events.

## Why a Unified Engine Matters

For the broader architecture, read [Reasoning Architecture](https://docs.concurrence.com/agent/universal-reasoning.md). It explains why a reasoning system combines software-defined problems, exact computation, fast decisions, and model deliberation over source-linked views, and distinguishes that design from the execution contracts on this page.

A workflow's objective can stay the same across channels even when its interaction changes. An availability lookup may support a spoken conversation or an asynchronous message. The agent still needs to interpret the request, use the permitted tools, and explain their result, while each channel handles waiting, interruption, and delivery differently.

Concurrence separates reusable agent and problem definitions from those channel concerns. Teams can change workflow guidance without rebuilding audio transport, or add a supported channel while retaining the same authored objectives. Each channel still needs its own validation.

<figure><img src="https://3635224444-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FvcLyiHRcwv7g83p6vxAd%2Fuploads%2Fgit-blob-170f3188ec2a0504269f66c2662a1f888642b98c%2Freasoning-engine-blue.svg?alt=media" alt="Shared agent, graph, and tool definitions support distinct execution paths: text returns responses and effects; simulation captures evidence with dry-run tools by default; platform-managed voice streams generated speech; provider realtime uses one ActionState with platform-controlled tools, playback, and call control."><figcaption><p>Shared definitions support reuse. Each runtime has its own input, execution, and delivery contract.</p></figcaption></figure>

## What the Designer Controls

Agent and Context Graph definitions are declarative assets: they describe the intended behavior and can be versioned, reviewed, and evaluated together.

| Part                             | Designer specifies                                                         | Role during execution                                                   |
| -------------------------------- | -------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| **Agent**                        | Role, communication style, and general guidance                            | Gives the model a consistent perspective for interpreting the task      |
| **Context Graph**                | Objectives, states, transitions, and state-specific instructions           | Defines the problem and the paths available for addressing it           |
| **Tool binding**                 | Eligible operations, execution timing, result delivery, and retention      | Connects a state's work to the tools and result-handling rules it needs |
| **Service and runtime controls** | Channel settings, authorization, validation, and supported safety behavior | Apply the operating boundaries for that deployment                      |

Use model judgment where interpretation is useful, such as understanding a request or explaining available options. Put requirements that must block an operation into the corresponding authorization, validation, or supported approval boundary. A state instruction to obtain confirmation guides the agent. An enforced confirmation requirement also needs a tool or approval check that rejects execution without it.

This lets a workflow vary how much judgment each step allows. It does not make model-backed navigation or responses deterministic. See [Context Graphs](https://docs.concurrence.com/agent/context-graphs.md) and [Runtime Safety](https://docs.concurrence.com/operations-and-safety/runtime-safety.md) for the specific controls.

## Cut, Navigate, Affect <a href="#cut-navigate-engage" id="cut-navigate-engage"></a>

Three responsibilities explain the architecture. They describe different decisions, rather than three mandatory model calls:

| Responsibility | Decision                                                     | Current execution boundary                                                                                                                                      |
| -------------- | ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Cut**        | Which input belongs together for processing?                 | Platform-managed voice captures a bounded packet with the transcript and available confidence evidence. Text begins with a message or supported event.          |
| **Navigate**   | Which computation or workflow step should handle that input? | Native graph navigation selects within the authored workflow. Eligible processing can also update context or channel control without generating a reply.        |
| **Affect**     | Which output or action can proceed, and when?                | Channel-specific controls coordinate speech, interruption, tool execution, and delivery. A selected action still needs its authorization and completion checks. |

The term **engage** has a narrower role in the current implementation: generating a response and tool calls, or preparing the voice timeline's selected behavior. Engagement is not the entire effect-arbitration responsibility. The [voice timeline](https://docs.concurrence.com/channels/voice/audio-pipeline.md#voice-timeline) uses its own cut/navigate/engage cycle to coordinate fillers, pauses, progress narration, and responses.

A packet is a processing boundary, not necessarily one transport message. A cut does not by itself mean that speech stops. Likewise, selecting work does not mean that an external action completed. See [universal processing responsibilities](https://docs.concurrence.com/agent/universal-reasoning.md#the-broader-universal-processing-engine) for the design model and [the pipeline](#the-pipeline) for the distinct runtime paths.

## Signals and Effects

The engine communicates through two primitives.

**Signals** represent something that happened. On signal-processing paths, adapters normalize relevant input into typed signals:

| Signal             | What It Represents                                                            |
| ------------------ | ----------------------------------------------------------------------------- |
| **Utterance**      | The caller or user said something (text, from any source)                     |
| **Tool result**    | A tool execution completed with a result                                      |
| **Silence**        | The caller has been silent beyond the configured threshold                    |
| **Barge-in**       | The caller interrupted the agent mid-speech                                   |
| **External event** | An injected event from an operator, surface submission, or external system    |
| **System**         | A system-level event such as a timeout, connection change, or error condition |

**Effects** are typed outputs in the shared reasoning contract. Some request future delivery, and others report work already performed. For example, a tool-called effect can report a tool invocation that the reasoning path has already executed, rather than ask a downstream scheduler to execute it again. The specific type and runtime determine the lifecycle. The table maps output concepts to channel behavior. It does not imply one identical effect-consumption loop or prove external completion:

| Effect                 | Voice                                                      | SMS                                                                       | Simulation                                                                             |
| ---------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| **Respond**            | Stream the generated response through the voice pipeline   | Send as an SMS message                                                    | Capture as simulation output                                                           |
| **Filler**             | Play filler audio ("Let me check on that...")              | No-op                                                                     | No-op                                                                                  |
| **Pause**              | Hold deliberate silence                                    | No caller-facing output                                                   | Capture the effect when applicable                                                     |
| **Tool call / result** | Execute through the voice tool path and process its result | Supported execution path may report the completed invocation as an effect | Dry-run or configured mock by default. Explicitly selected eligible reads can run live |
| **Terminate**          | Hang up after final speech                                 | End session                                                               | Return final state                                                                     |
| **Transition**         | Records a state change with no caller-facing output        | Same                                                                      | Capture in trace log                                                                   |
| **Observe**            | Emits an analytics event with no caller-facing output      | Same                                                                      | Capture in trace log                                                                   |

## The Pipeline

The interaction can be understood through three stages. A signal can update context or control the channel without requiring a new model response. For example, barge-in can interrupt playback.

**Perceive.** Text and simulation convert supported input into typed signals. Platform-managed voice forms processing packets from recognized speech and supported events, retaining the available confidence evidence at the input boundary. This gives processing a consistent input snapshot while new signals can continue to arrive.

**Reason.** The native state-machine path implements cut/navigate/engage at the conversation level:

1. **Navigate** - The context graph engine determines the current state, evaluates transition conditions, and selects the appropriate action.
2. **Engage** - The response generation model produces a reply, drawing on the agent's persona, current state guidance, selected memory, patient data from the world model, and the empathy guidance described below.
3. **Execute** - If the model calls tools, the engine executes them, supplies their results to subsequent reasoning, and re-engages within the configured execution limits.

**Act.** The selected runtime turns reasoning results into channel output. Text and simulation can return materialized effects. Native voice consumes navigation and engagement prompts through its streaming pipeline. The [voice timeline](https://docs.concurrence.com/channels/voice/audio-pipeline.md#voice-timeline) coordinates fillers, empathy pauses, and tool progress narration within each turn.

The execution paths reuse components without sharing one complete runtime loop:

| Path                              | How reasoning reaches execution                                                                                                | Boundary to preserve                                                                                                                                                                                       |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Native text and simulation**    | Process signals through the shared reasoning entry point and expose supported effects or streamed results                      | Delivery, persistence, and simulation write behavior remain path-specific                                                                                                                                  |
| **Native voice**                  | Uses shared navigation and engagement components, then streams speech through its voice pipeline                               | Consumes navigation and engagement prompts rather than the same completed-effect list                                                                                                                      |
| **Provider-owned realtime voice** | The provider generates the conversation, and platform controls govern tool execution, playback, interruption, and call control | `gpt_realtime` supports one ActionState or 2 to 12 with unique names and valid exits. The model requests moves and can stay put. `eleven_realtime` requires exactly one. Neither uses per-state TurnPolicy |

Response streaming can reduce the wait for complete text before delivery. It does not make these execution paths equivalent. Confirm the service's selected runtime and provider when relying on state-specific behavior.

Simulation tools return dry-run results or configured mocks by default. Supported simulation launches can opt eligible reads into live execution. Writes and approval-gated tools remain simulated, and companion skills do not run live. The text Playground and browser test calls run tools live. See [Simulations](https://docs.concurrence.com/testing/testing/simulations.md) before choosing a test surface.

Filler handling is channel-aware. Voice can play a short acknowledgement while work continues. Asynchronous messaging channels suppress voice-style filler and deliver results through their channel-specific completion flow. See [Email](https://docs.concurrence.com/channels/email.md#long-running-tools-and-reply-delivery) for a non-live example.

Navigation can also be re-evaluated after a successful tool result rather than waiting for another user message. This occurs only for tool bindings configured for completion-gated navigation. The navigator may remain in the current state or select another valid state. See [Action State Extensions](https://docs.concurrence.com/agent/context-graphs.md#action-state-extensions).

## Empathy Adaptation

On each caller or user turn, a model-backed read of the turn's words classifies the support it calls for: Functional, Light Touch, Full Empathy, or Hold Space. At Full Empathy the response prompt asks the reply to open with empathy, and at Hold Space the whole reply is empathy and does not advance the task. On voice, the tier also sets the empathy pause and whether a filler is an empathy filler or a plain receipt. See [Empathy-Gated Filler Behavior](https://docs.concurrence.com/channels/voice/audio-pipeline.md#empathy-gated-filler-behavior).

The tier is model-derived guidance for the reply, not a verified statement about the caller's internal state, and safety or clinical decisions should not rely on it alone.

## Per-State Configuration (TurnPolicy)

Each context graph state can configure the pipeline independently, except on `gpt_realtime`, which reads none of a state's turn policy. A medication verification state behaves differently than a general scheduling state - not because the reasoning logic changes, but because the state's turn policy tunes the pipeline for that context.

<figure><img src="https://3635224444-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FvcLyiHRcwv7g83p6vxAd%2Fuploads%2Fgit-blob-5cde10eb7d026599eff72438907dad513683c0ed%2Fturn-policy-green.svg?alt=media" alt="TurnPolicy scope: platform-managed voice uses barge-in, forwarding restrictions, and supported speech-recognition controls; voice and text use context strategy. State-tool bindings separately define workflow tools. Provider realtime does not read TurnPolicy."><figcaption><p>Per-state settings apply only on the runtime and recognition paths that consume them. Tool bindings are a separate configuration surface.</p></figcaption></figure>

Four areas are configurable per state:

* **Barge-in** - Enable or disable caller interruptions for the active state. The service's minimum speech duration applies during the greeting as well as later responses, and there is no separate greeting-shield duration. A quick-answer state can keep barge-in enabled for faster turn-taking.
* **Context strategy** - Choose full history or compact past state groups. With compact history, a per-state threshold caps how much history the prompt keeps, and the engine can also ratchet to compact mode when prompt usage approaches the engine's context limit.
* **Forwarding restrictions** (voice only) - On the platform-managed runtime, turn policy can block call forwarding entirely or after a configured number of turns. State-tool bindings separately define workflow actions, and TurnPolicy is not the general tool registry.
* **STT sensitivity** (voice only) - End-of-turn thresholds and silence timeouts, on recognition paths that accept changes during a call. An English call on the default recognizer ignores them. Data collection states use higher thresholds and longer timeouts because callers pause between pieces of information. Quick-answer states use lower thresholds for faster responses.

On `gpt_realtime`, the service's `barge_in_min_speech_s` applies after the call opening. See [Barge-in](https://docs.concurrence.com/developer-guide/platform-api/workspaces/voice-configuration#barge-in) for how it cuts a reply.

## Model Configuration

Navigation and engagement are separate responsibilities. Native navigation uses a platform-managed decision path to choose among the graph's permitted alternatives. Engagement handles tool calling and response generation through the selected runtime's supported model configuration. A model preference field does not establish that every runtime uses it. Model-backed navigation and response generation remain probabilistic.

## Graceful Degradation

Selected failure paths have bounded fallbacks so an optional subsystem or a single model timeout does not automatically end a session.

| Component               | Failure                                            | Fallback                                                                                         |
| ----------------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Navigation decision** | Timeout, invalid choice, or unusable decision      | Retains the current state and action for engagement rather than selecting an unchosen transition |
| **Context pressure**    | Prompt usage approaches the engine's context limit | Compacts past state groups and caps retained history                                             |

These paths reduce failure propagation, but they are not a zero-failure guarantee. Transport loss, exhausted fallbacks, session limits, or failures in required dependencies can still interrupt or end an interaction.

## Voice Control Plane

Voice calls combine service, agent, and workspace settings with platform defaults to control vocal identity and delivery. They do not use one universal override hierarchy. Each field family has its own resolution rule.

<figure><img src="https://3635224444-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FvcLyiHRcwv7g83p6vxAd%2Fuploads%2Fgit-blob-092315c2d562ad7054774e86e3b269089ff56e67%2Fvoice-control-plane-blue.svg?alt=media" alt="Platform-managed voice separates field-specific configuration resolution, active-state TurnPolicy, and best-effort signal-based adaptation. These are distinct scopes rather than a single inheritance chain."><figcaption><p>Platform-managed voice. Provider realtime does not read per-state TurnPolicy.</p></figcaption></figure>

| Setting Family                           | Resolution                                                                                                                                                                                                                                                                                                                                                            |
| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Service pipeline tuning**              | A service value applies when set. Otherwise the field uses its documented runtime default or supported fallback                                                                                                                                                                                                                                                       |
| **Session provider**                     | Service, then agent, then `concurrence`, the platform-managed runtime                                                                                                                                                                                                                                                                                                 |
| **TTS provider**                         | On the platform-managed runtime: service, then agent, then workspace, then the [Default TTS Model](https://docs.concurrence.com/developer-guide/platform-api/workspaces/voice-configuration#default-tts-model) rule. Per-language maps check the exact language, base language, and `multilingual` key, with service, agent, and workspace precedence within each key |
| **TTS provider configuration and model** | On the platform-managed runtime: workspace provider configuration forms the base, then agent and service configuration override it. A service model is the final model override, and unresolved values use the platform defaults. A selected per-language entry can replace the merged base provider configuration                                                    |
| **Workspace voice settings**             | Provide voice identity, tone, speed, volume, language, domain vocabulary, sensitive topics, and other workspace baselines for the fields that consult them                                                                                                                                                                                                            |
| **Per-state `TurnPolicy`**               | Controls separate state behavior: barge-in and STT sensitivity on the platform-managed runtime, with STT sensitivity only where the recognizer supports it, and context strategy on that runtime and in text conversations. It is not another provider-inheritance tier                                                                                               |

On `gpt_realtime`, the voice comes from `realtime.voice` and the call's language is the agent's default language, English when it is empty or not recognized. A service that serves English and Spanish from an English default runs the bilingual session instead. See [Languages a Service Serves](https://docs.concurrence.com/developer-guide/platform-api/conversations/voice-agent#languages-a-service-serves).

Navigation can select a turn-specific tone from a fixed tone set, based on the conversation. Without one, an explicit workspace tone or a sensitive-topic match sets the computed voice context, and provider defaults apply when no turn tone is available. This tone choice is separate from provider and TTS configuration resolution. See [TTS Tone Resolution](https://docs.concurrence.com/channels/voice/audio-pipeline.md#tts-tone-resolution).

## Concurrency

User input, reasoning, tool execution, and delivery can overlap. A caller can correct a request while a lookup is running, and a tool can finish after the agent has stopped speaking. Receiving information, continuing reasoning, and delivering a response are separate decisions.

Supported runtimes coordinate accepted interaction work while tools and background tasks can run independently. A tool binding separately controls whether work blocks or runs in the background, how success and failure return to the interaction, and how results are retained. Lifecycle support differs by modality. See [Tool Dispatch Configuration](https://docs.concurrence.com/agent/context-graphs.md#tool-dispatch-configuration).

For example, with a voice lookup configured for background execution and interrupt delivery:

1. The caller asks for Friday's availability and the agent starts the lookup.
2. The voice runtime manages waiting and any configured progress speech while the lookup runs.
3. When the result is ready and continuation is permitted, the agent can present the options without another user message.
4. If the caller changes the request, the new input can interrupt speech and start another reasoning step. The completed lookup and whether to speak about it remain separate. Continuation checks account for newer input and pending transcription, but do not establish universal rejection of every stale result.

With several outstanding voice tools, the current continuation path waits for the last completion before considering an automatic response. Earlier results can be recorded without generating separate responses.

Interrupting speech does not undo a tool's completed action. Requesting cancellation is also different from confirming that work stopped. For an external write with an uncertain outcome, check the operation's documented completion status or supported read-back before deciding whether to retry. A transport acknowledgement alone does not establish that the requested change happened.

Voice coordinates fillers, responses, empathy pauses, and progress narration on one timeline. Text uses its supported conversation and background-result lifecycle. These controls do not promise identical delivery timing, recovery of every in-flight task, or bit-exact replay across channels. See [Text Sessions](https://docs.concurrence.com/channels/text-sessions.md) and the [Voice Timeline](https://docs.concurrence.com/channels/voice/audio-pipeline.md#voice-timeline).

## Design Direction: Universal Reasoning Harness

The proposed harness extends the shared reasoning contract to work whose input, reasoning, actions, and delivery have independent lifetimes. An external record update could lead to background work and an observed outcome without a conversational reply. The design retains declarative agent and problem definitions while making dependencies, context validity, and ownership of ongoing work explicit.

The broader [universal processing engine design](https://docs.concurrence.com/agent/universal-reasoning.md#the-broader-universal-processing-engine) separates cut policy, consumer dispatch policy, and effect arbitration policy. This harness develops execution ownership within that architecture. A priority queue, one worker layout, or serial packet processing is an implementation choice rather than a required property of the design.

Current implementations provide the channel behavior described above. Full execution ownership, background behavior selection, and general evidence-preload support are proposed extensions. Their presence in this design does not establish support in every runtime or deployment.

### Capture Context, Decide, and Accept Work

| Step        | Purpose in the proposed harness                                                                               |
| ----------- | ------------------------------------------------------------------------------------------------------------- |
| **Cut**     | Capture a bounded selection of relevant context while new signals can continue to arrive                      |
| **Reason**  | Interpret that context using the agent and problem definition, through deterministic rules or model reasoning |
| **Enqueue** | Accept intended work with priority, dependencies, and conditions under which it remains valid                 |

A signal supplies information, and the harness decides whether that information requires work. A cut creates a context boundary and need not interrupt current activity. Interruption or invalidation becomes necessary when changed assumptions affect unfinished work. Priority orders work that is eligible to proceed. It cannot satisfy a missing prerequisite or grant permission.

The bounded input captured at a cut is a *processing packet*, called a *quantum* in earlier harness designs. Its scope follows the task rather than a network-packet boundary. Smaller units allow earlier reconsideration but can add overhead and discarded reasoning. Larger units preserve more continuity but can leave more work to reconsider after a correction. Forming a packet does not require every consumer to run or produce an output.

One execution owner would accept changes to state and scheduling. Concurrent workers would return proposed guidance, results, or outcomes for that owner to check. The owner would check relevance when accepting a result and again before releasing dependent work, while remaining responsive to control signals during long model requests.

For example, a Friday behavior selection that finishes after the request has changed to Monday must not restore Friday's instructions merely because it completed last. The proposed acceptance checks generalize the narrower voice continuation checks above. Replacement of an execution owner must also prevent the previous owner from continuing to accept changes.

### Background Guidance and Required Evidence

The proposed background selector would compute behavior guidance against captured context while other eligible work continues. Advisory guidance could be adopted at a later reasoning boundary. If an action or response requires a selection, that dependency would hold the affected work until selection succeeds or the defined fallback resolves it. Mandatory constraints remain enforced while selection is pending or fails.

The same distinction applies to [memory and required evidence](https://docs.concurrence.com/agent/memory.md#context-required-by-a-task). Loading information early can reduce waiting, while required evidence gates the decision that uses it. New contradictions or missing facts can trigger additional authorized retrieval even when they were absent from the initial context declaration.

A model request already in flight has received its context. Accepting new guidance means using it in a later request or cancelling and regenerating unfinished output. Changing shared instructions does not rewrite the active request. A correction can require a new decision, while an ordinary update may wait until the next boundary.

Voice filler can acknowledge that work is continuing. Its usefulness depends on measured timing: initial silence, any gap after the filler, and time to meaningful output. Filler does not satisfy a prerequisite or restart the latency measurement.

### Recovery and Human Control

The target contract distinguishes an intended action, its submission attempts, and its confirmed outcome. Recovery would retain pending obligations or explicitly mark them unresolved. An uncertain external submission requires the provider's supported idempotency or reconciliation path before retrying. Execution ownership alone cannot guarantee exactly-once effects.

Operator guidance, takeover, and handback need separate authority and scope. The proposed harness would reconsider affected pending work after handback and retain already submitted actions for reconciliation. Current controls and channel limits remain documented in [Operators](https://docs.concurrence.com/operations-and-safety/operators.md). This design does not promise restoration of every dropped call or recovery of every running tool.

Evaluate recorded-result replay separately from rerunning models. The former inspects execution handling for supplied outcomes, and the latter also measures model variability. Agree on covered failures, recovery deadlines, meaningful-output latency, and total cost under a stated workload before assigning production targets. See [Evaluating Concurrence](https://docs.concurrence.com/platform-overview/evaluating-amigo.md).

## Modality Adapters

Adapters and channel runtimes handle the following input and output responsibilities on the supported native paths. These are behavior categories, not a claim that every channel consumes the same effect objects. Provider-owned realtime voice follows its separate session lifecycle described above.

| Adapter        | Signal Production                                                                                         | Output Handling                                                                                                              |
| -------------- | --------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| **Voice**      | Recognized speech and supported events form input packets. Silence and barge-in follow the voice timeline | Streams responses through TTS and manages fillers, pauses, and termination within the voice lifecycle                        |
| **Text (SMS)** | Incoming messages produce utterance signals                                                               | Respond effects send SMS messages, and terminate effects end the session                                                     |
| **Simulation** | Test parameters inject utterance signals                                                                  | Captures simulation evidence. Tools use dry runs or mocks, with live execution limited to explicitly selected eligible reads |

New modalities can reuse the signal-and-effect contract through an adapter. Channel-specific delivery, lifecycle, authorization, and failure handling still require integration and testing.

{% hint style="info" %}
**Related sections** - See [Context Graphs](https://docs.concurrence.com/agent/context-graphs.md) for how the engine navigates problem spaces, [Functional Memory](https://docs.concurrence.com/agent/memory.md) for bounded cross-session context, and [Voice Agent](https://docs.concurrence.com/channels/voice.md) for voice-specific pipeline details. [Dynamic Behaviors](https://docs.concurrence.com/agent/context-graphs/dynamic-behaviors.md) covers guidance chosen on each caller turn from a workspace library.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.concurrence.com/agent/reasoning-engine.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
