G-1 Studio¶
G-1 Studio turns the single-upstream Geodesia gateway into an Application-oriented platform. Instead of one gateway wrapping one LLM, you now run many self-contained Applications, each with its own model, policy, thresholds, knowledge base, compliance posture, and cost center — all managed from one control plane and served from one engine.
Backward-compatible by design
Everything in Studio is additive. An existing single-upstream deployment surfaces as the default Application with zero behaviour change — the same chat endpoint, the same detection, the same compliance ledger. You opt into multi-Application features when you need them.
What is an Application?¶
An Application is 1 LLM + GLAD-Hummingbird in the middle, owning everything that makes that LLM safe, compliant, and accountable:
Binding
The upstream LLM it routes to — openai, ollama, vllm, sglang, trtllm, bedrock, vertex, azure-openai, or internal.
Policy
Per-axis thresholds and enforcement modes across the 6 detection axes, plus block_input, system-prompt injection, and the streaming brake.
Threshold profile
A named calibration_profile binding the app to its model-specific detection thresholds.
RAG knowledge base
Its own isolated document collection. Cross-app reads are refused — one app can never see another's documents.
Governance
FRIA record, applicable laws, retention window, risk classification, and human-oversight triggers — scoped to this app.
Cost center
Token pricing, monthly budget, alert percentages, and an alert-or-block policy when the budget is exceeded.
The full configuration lives in a single AppConfig (binding · policy · cost · governance). See Applications for the field-by-field reference.
Organizations¶
Applications are grouped under Organizations. An organization carries the license entitlement max_applications — the maximum number of Applications it may create. A free-tier organization is limited to 1 Application; higher tiers raise the limit (see Licensing).
| Concept | What it holds |
|---|---|
| Organization | org_id, name, country, license_type, max_applications |
| Application | app_id, org_id, status, config_json (the AppConfig), config_version |
| API key | g1k_live_* invoke key, sha256-hashed, scoped to one Application |
Two planes, one engine¶
G-1 Studio cleanly separates management from serving:
- Control plane —
/v1/glad/apps/*. Create and configure Applications and Organizations, mint API keys, edit policy, read cost / metrics / forecast. See Control-Plane API. - Data plane — the chat path. Each request resolves its Application, GLAD-Hummingbird scores the 6 axes, the request is routed to that app's LLM, and the call is logged with its cost.
The control plane writes Application config; the data plane reads it on every chat request to score, route, and bill against the right Application.
The 6 detection axes¶
GLAD-Hummingbird scores every request across six independent axes, grouped by where in the request lifecycle they run. Each axis has its own threshold and enforcement mode in the app's policy.
| Region | Axes | Runs |
|---|---|---|
| Prompt / context | prompt_safety, jailbreak, rag_jailbreak | Before the LLM is called |
| Answer | halluc_context, halluc_closedbook, answer_safety | After the answer is generated |
The rag_jailbreak axis is the context-injection firewall: it catches adversarial instructions smuggled in through retrieved documents or tool outputs.
Per-axis defaults
Studio ships serving-calibrated defaults (gemma4-e2b, FPR≈0.07): prompt_safety 0.70, jailbreak 0.50, rag_jailbreak 0.05, halluc_context 0.32, halluc_closedbook 0.58, answer_safety 0.90. Prompt-region axes default to block; answer-region axes default to annotate. Missing axes are always backfilled so the 6-axis contract holds downstream.
For the full behaviour of each axis, see Detection Axes.
The App switcher¶
The Studio topbar carries an App switcher that selects the active Application. The active app determines which configuration the UI edits and which data the app-scoped views display.
On the data plane, the Application for a chat request is resolved from, in order:
- an explicit
application_id(orapp_id) field in the request body, or theX-Geodesia-Apprequest header — this always wins; - failing that, an Application API key sent as
Authorization: Bearer g1k_live_…— the gateway looks up the key and routes the request to the Application it belongs to.
Only g1k_-prefixed bearers are looked up (other bearers, including GW_API_TOKEN, are ignored); a revoked, expired, or unknown key, and an unknown application_id, all fall back to the default Application — which is why an existing single-upstream deployment keeps working unchanged.
Per-Application scoping¶
When an Application is active, the following UI areas scope to that app — they show only that Application's data and edit only that Application's configuration:
| Area | What scopes |
|---|---|
| Dashboard | Call metrics (passed / blocked / hallucinated / unsafe) filtered to the active app |
| Human Oversight | Pending reviews for the active app |
| Kill Switch | Acts on the active app |
| FRIA | The active app's risk record |
| Reports | Compliance reports for the active app |
| Knowledge Base | The active app's isolated RAG collection |
| Chat | Sends application_id so messages route to and bill against the active app |
The following areas are global and not app-scoped:
| Area | Why it is global |
|---|---|
| Legal Frameworks | Shows the full catalog of all frameworks regardless of the selected Application |
| API Docs | Reference material, not per-app data |
| Documentation | This site — not per-app data |
| Causal / AgentFlow | Operate on an explicitly-selected call, not per-app aggregates — so no misleading "scoped" banner is shown |
Free tier limits¶
Free tier
The free tier is limited to 1 Application and 20 chats/day. Raising the Application limit (max_applications) and the daily chat allowance requires a licensed entitlement. See Licensing for the details.
Where to next¶
| I want to… | Go to… |
|---|---|
| Configure an Application end-to-end | Applications |
| Set budgets and read cost / forecast | Cost & FinOps |
| Call the management endpoints | Control-Plane API |
Understand tiers and max_applications | Licensing |
| Bind a cloud LLM (Bedrock, Vertex, Azure) | Cloud Upstreams |
| Understand the 6 detection axes | Detection Axes |