Galactre
USD

Choose how catalog prices and estimates appear. Checkout and account records remain in IDR.

Open Chat

GALACTRE / AGENT PLATFORM

From a question
to a workflow.

Bring model reasoning into the work your application manages. Explore how Galactre can help plan, explain and review, with context, permissions and human decisions kept in view.

Available foundation: text generation and conversation context.
Managed multi-agent runs and tool execution remain planned.

01 / A PRACTICAL FOUNDATION

Intelligence with
a place in the process.

A model response can be one step in a larger system. Start with the capabilities available today and give each surrounding component a clear responsibility.

Text generation

A model for the reasoning step

Use GT to explain a problem, draft a plan or review supplied material. Select an available family from the catalog and define what a useful response should contain.

Explore model families

Conversation context

Context with clear boundaries

Continue a conversation using its saved ID. The current chat includes bounded recent messages; it does not automatically read your repository, browse a website or retrieve private documents.

Understand conversation context

Guest and account sessions

Access appropriate to the task

Try a limited Lunar conversation as a guest. Use an IAMC account for separate account history and billing, and check the published Galactre contract before planning a server integration.

Read the access contract

Review in your application

Results you can inspect

Treat generated plans, code and checklists as proposed artifacts. Your application owns validation, approval and any action taken after a response.

Design an evaluation

02 / EXPLORE THE HANDOFFS

Useful work.
Visible responsibilities.

Explore three illustrative workflows. Select a stage to inspect its input, responsibility and expected artifact. These blueprints do not run agents, tools or deployments.

From a change to a reviewable proposal.

Use a focused diff and explicit criteria to prepare review notes. The model produces text; repository reads, test execution and merge decisions belong to your application and reviewers.

ILLUSTRATIVE STAGE / 01

Collect the relevant change

Your application obtains an authorized diff, runtime information and acceptance criteria. Exclude credentials and unrelated private files.

Input: a bounded diff, stated constraints and review criteria.
A STARTING PROMPT
Help me prepare a code review. I will supply a diff, runtime version and acceptance criteria. First identify missing context. Then organize your review into correctness risks, security concerns, proposed tests and questions for the author. Do not claim repository access or test execution. Wait for the diff before making findings.

Prepare this prompt in chat

The link opens a draft. No model request is sent until you submit it.

03 / THE SYSTEM BOUNDARIES

Give every layer
a clear job.

Keep model reasoning, workflow state and real-world execution distinct. The integration is easier to inspect when each layer owns a defined boundary.

01

Your application

Workflow owner

Owns user permissions, source retrieval, task state, tools, approvals and artifact storage. It decides which context may be sent and which actions are allowed.

02

GT

Model family

Provides the GT model identity, text generation and bounded chat context. Requests follow session or workload authorization and the model catalog.

03

Galactre service

Managed execution

Checks service access, model availability and usage policy before processing a request. Service credentials and operational configuration stay on the server.

04

Your controlled runners

Execution boundary

Run tests, apply changes and deploy only under your own isolation and approval policy. A generated plan is input to that process, not permission to execute it.

04 / FOR DEVELOPERS

Connect the model step.
Own the workflow.

The current browser contract uses a same-origin session and CSRF protection. It returns a completed text response. Tool execution, output validation and subsequent actions are implemented by your application.

  1. 01

    Discover an available model

    Read the current catalog and choose a supported family. Availability, workload permission and service health are independent checks.

  2. 02

    Use the correct access path

    The browser example uses a same-origin session and CSRF. For backend integrations, create a model-scoped server key in API Access and use the responses endpoint with an Idempotency-Key.

  3. 03

    Send a bounded task

    Provide only the relevant, authorized context and a clear output request. Keep credentials and private tool results outside a guest session.

  4. 04

    Validate before taking action

    Accept completed results, handle errors explicitly and review the content. Reconcile an uncertain outcome before retrying a sensitive downstream operation.

JAVASCRIPT / SAME-ORIGIN BROWSER
// Run from a page on the Galactre origin. Nothing runs until you call it.
async function prepareReview(message) {
  const catalog = await fetch('/api/v1/chat/models').then(r => r.json());
  if (!catalog.models?.some(m => m.family === 'Lunar' && m.available)) {
    throw new Error('Lunar is not currently available.');
  }
  const session = await fetch('/api/v1/chat/session', {
    credentials: 'same-origin'
  }).then(r => r.json());
  if (!session.chat_available || !session.csrf_token) {
    throw new Error('Chat is temporarily unavailable.');
  }
  const response = await fetch('/api/v1/chat/generate', {
    method: 'POST', credentials: 'same-origin',
    headers: {
      'Content-Type': 'application/json',
      'X-CSRF-Token': session.csrf_token
    },
    body: JSON.stringify({ model: 'gt-lunar', message, request_key: 'example_' + crypto.randomUUID().replaceAll('-', '') })
  });
  const result = await response.json();
  if (response.status === 429) {
    throw new Error('Rate limited. Honor the Retry-After header.');
  }
  if (!response.ok || result.status !== 'completed') {
    throw new Error('Inspect the request outcome before retrying.');
  }
  // Review this text. It is not a tool command or execution approval.
  return { text: result.response, conversationId: result.conversation_id };
}

05 / KEEP CONTROL OF THE WORK

Context is not permission.
A proposal is not execution.

Design access and recovery around the actions your application actually performs. Give the model only the context needed for the current task.

Separate identities and histories

Guest history belongs to its browser session; signed-in history is separate. Conversation reads and deletion are scoped to the current identity. Guest access does not grant workspace permissions.

Keep service credentials on the server

The browser uses a server session and CSRF protection. Service credentials are configured server-side, with access checked before execution.

Respect limits and uncertain outcomes

Check current guest limits from the session endpoint and honor 429 / Retry-After. A timeout or indeterminate result requires inspection; it is not proof that downstream work never happened.

Authorize every external action

Code writes, commands, payments and deployments need permissions enforced by your application. This chat release does not expose a tool execution API or grant agents those capabilities.

Review data processing and retention before supplying sensitive material. Read the privacy policy

06 / WHAT YOU CAN USE

The foundation today.
The direction ahead.

Capability status below describes the current product implementation. Runtime access still depends on your session, the model catalog, limits and service health.

Text conversation

Guest and signed-in chat, subject to model availability, quotas and execution policy.

Implemented

Bounded conversation history

Saved conversations scoped to the current identity, with bounded recent messages as context.

Implemented

Code and document assistance

Discuss supplied code or excerpts. No automatic repository access, browsing or document retrieval.

Text assistance

Multi-agent orchestration

A native planner, delegated agents, dependencies and run dashboard are not available in this release.

Planned

Tools and execution sandboxes

No public shell, file execution, deployment tool or managed sandbox endpoint is provided by GT chat.

Not exposed

MCP, agent identity and settlement

A public MCP server, on-chain agent registry, agent wallet and autonomous settlement API have not been published.

Product direction

The model catalog could not be reached. Reload before selecting a model.

Roadmap items have no release date on this page. Buying credits does not activate an unavailable capability.

07 / QUESTIONS, ANSWERED

Build with a
clear understanding.

How should a workflow choose its GT version?

Pin an available exact release when validating a repeatable workflow. Use a family default when you deliberately want future approved promotions. Record the resolved model ID with each result; model versioning does not grant execution tools or external system permissions.

Is GT a model family or a complete agent runtime?

GT is the AI model family developed by Galactre, with model access and text conversation available through the Galactre service. The agent platform direction extends that foundation, but native multi-agent scheduling, hosted tools and execution sandboxes are not available in this release. The workflow examples show how an application can use the model step.

Can I try the workflow examples without logging in?

When guest chat is enabled, you can open a sample prompt as a draft and send a limited Lunar request. Guest access does not read a repository, run tools or unlock a workspace. Review the session limits before sending.

Can Galactre change my code or deploy my project?

This chat release generates text. It can propose a change or a checklist from supplied information, but a consuming application must separately provide repository access, an isolated runner and the required approval policy before any real action.

Can another application build a workflow around Galactre?

Start with the published Galactre integration contract and its current access requirements. Your application owns retrieval, tools, approvals and execution. Native integrations are documented as available only after their service contract and operational deployment have been verified.

Does a saved conversation act as a knowledge base?

No. Recent messages provide bounded conversation context. Document ingestion, search, durable agent memory and retrieval permissions require separate systems controlled by your application. Supply only the material the current task is allowed to use.

Does the API example support tool calls or token streaming?

The minimal example requests JSON. Set stream to true for real SSE events and use the request cancel endpoint to stop delivery. Signed-in browser conversations can retrieve selected private knowledge and use calculator or current-time tools. Server keys cannot delegate those private sources. Arbitrary tools and execution sandboxes are not released.

Where should I start for a production integration?

Read the developer contract, verify a supported access path, test with representative inputs and define limits, error handling and review requirements. Keep external actions behind your own permissions, audit and recovery process.

START WITH ONE USEFUL STEP

Bring your task.
Keep the decisions yours.

Try an available GT model, inspect the result and design the workflow around evidence.