Concepts

Flowstate runs a closed loop: capture what happens, attribute it, score it, raise signals, enforce policy. Here's how the pieces line up.

What "AI" means here

AI isn't just coding tools. The platform tracks the full landscape — image generation, video generation, audio and voice, sales-enablement copilots, marketing copy and creative assistants, legal research, enterprise search, and the long tail. Coding tools are where Flowstate's coverage runs deepest today, because that's where the agent and the provider billing APIs give us the most signal. The other modalities are tracked to the extent the agent observes their traffic or a billing-API connection sees their invoices. See Catalog for the full picture of what's visible right now and what's roadmap.

The loop

   ┌─────────────────────────────────────────────────────────────┐
   │                                                             │
   │     [ Agent on developer machine ]                          │
   │              │                                              │
   │              │   captured sessions, tokens, models, prompts │
   │              ▼                                              │
   │     [ Telemetry ingest ] ──► [ Attribution ]                │
   │              │                       │                      │
   │              │                       ▼                      │
   │     [ Provider billing pulls ] ◄► [ Reconciliation ]        │
   │                                      │                      │
   │     [ Fluency classifier ] ◄────────┤                       │
   │              │                       │                      │
   │              ▼                       ▼                      │
   │     [ Behavioural signals ] ──► [ Policy + enforcement ]    │
   │              │                       │                      │
   │              ▼                       ▼                      │
   │     [ Alerts, drawer, ack ]  [ Block / warn at request ]    │
   │                                                             │
   └─────────────────────────────────────────────────────────────┘

Telemetry

The Flowstate Agent sits on every developer machine and observes traffic to AI providers. It captures one of two payloads, depending on the pathway you've chosen:

• Telemetry — request metadata only: host, model, token counts, status, duration. No prompt or response body.
• Enterprise — full request and response, including prompts and tool calls. For orgs on Claude for Enterprise, ChatGPT Enterprise, and similar contracts.

Sessions stream to the ingest API, decorated with the agent's telemetry key — the per-employee or per-contractor credential that identifies who the traffic belongs to.

The Cloud Proxy is separate from these Agent capture modes. Its shipped network-proxy flow routes managed devices through ai.flowstate.inc and updates connection status plus a per-subject request meter. It does not by itself provide prompt-body capture, prompt-quality scoring, or request-time enforcement.

Attribution

A captured session is useless without a name on it. Flowstate resolves each session to:

• A subject — an employee or contractor, via the telemetry key on the session and the user-account headers in the request.
• A project — inferred from working context (open IDE project, git branch, recent commits) or marked manually by the engineer in My AI Usage.
• A team, cost centre, value stream — derived from the subject's allocations in the workforce model.

Attribution rolls up live in Insights → Attribution. When you click into a row, you can drill from org → cost centre → team → person → individual session.

Reconciliation

Observed usage and provider invoices rarely match exactly. Provider seat counts lag, retainers prepay months in advance, and edge cases like trial seats or shared accounts blur the picture.

The Spend reconciliation screen presents each provider-billing row in one of five buckets:

• Unreconciled — billed but no observed match yet.
• Suggested — auto-matched but pending confirmation.
• Confirmed — explicitly accepted.
• Written off — billed but won't be matched (with a note).
• Deferred — kicked into next period.

You work the unreconciled queue the way an accountant works Xero. Reconciled rows feed the official spend ledger; unreconciled ones get a residual-variance line on the period summary.

Fluency

Telemetry sessions in Enterprise mode are scored by a classifier on three competencies — the 3D fluency model:

• Description — how clearly the prompt frames the task.
• Delegation — how well the engineer hands off versus over-specifying.
• Discernment — how critically the engineer evaluates the response before accepting it.

A fourth competency — Diligence — exists in the model but isn't chat-observable, so it shows as muted on the Fluency overview.

Each competency is built from a static catalogue of indicators (e.g. "specifies acceptance criteria", "asks a clarifying question after a vague response"). The page shows org-wide prevalence per indicator, a 12-week trend, and a delta versus baseline.

Behavioural signals

Signals are the events you'd want to know about. The signal ingest pipeline raises them in four categories:

• Content safety — PII detected, secret leaked, API key in prompt, customer-data pattern, banned content.
• Brand and usage — brand-policy violation, off-topic in production, personal use of a company account, abuse pattern, wasteful prompting.
• Budget — forecast breach.
• Operational — monitoring gap, model regression, auth-context mismatch, key misuse.

Each signal carries one of three severities — INFO, WARN, BLOCK. The Alerts page defaults to WARN and BLOCK, grouped by category, with a manager-ack drawer for triage. Resolutions are acknowledged, false_positive (filters the rule), or escalated (note required, routes to security).

Policy and enforcement

A policy is a set of rules, versioned, with an explicit activeFrom. The active policy lives at Governance → Policy and enforcement along with the full version timeline and audit log.

In observe mode, the policy raises signals but doesn't change behaviour. In enforcement mode, the agent intercepts at request time and returns a 403 to the calling tool with the policy name and rule that fired. See Enforcement for the rollout sequence — observe for at least two weeks before flipping enforcement on.

Where the agent ends and the platform starts

The agent captures and (optionally) enforces. Everything else — attribution, reconciliation, fluency scoring, signal generation, policy storage, audit, the dashboards — runs in Flowstate. That separation matters: the agent is small, deterministic, and fail-open by design. If Flowstate is unreachable, the agent buffers locally and lets traffic through.

Next

• Pick a pathway: Telemetry vs Enterprise.
• Install the agent: macOS · Windows · Linux.
• Wire the provider billing APIs: Usage providers.