Genesis · Token Service

Make Every Token More Valuable

Built on application context, data and agent runtime expertise

Connect models, enterprise data, long-term memory and agent execution around a successfully completed task. Reduce unnecessary consumption in applications and keep improving inference and compute utilization for more efficient, economical and transparent model services.

Start Using Genesis Contact Sales Explore Token Efficiency

Model and token services within MatrixOne Intelligence

Successfully Complete the Task

Application Context

Data

Agent Runtime

Genesis

Model and Token Services

Optimize Consumption

Improve Compute Efficiency

Start with the task. Connect applications and compute.

Start with the Task

Align models, context and calling strategies

Understand Token Use

Connect model calls to task execution

Application to Compute

Improve consumption and production efficiency

From Call Costs to Task Costs

Look Beyond Token Prices to the Complete Task

As AI moves from simple conversations to complex agents, the price of one call explains only part of the cost. The context supplied, repeated reasoning and execution steps also shape what a task consumes.

Redundant Context

Irrelevant or repeated information keeps adding to model input.

Repeated Reasoning

Similar content is analyzed again when prior experience is underused.

Complex Execution

Multiple calls and debugging steps require visibility across the task.

Understand How Spending Leads to a Result

Prepare Context
Model Reasoning
Execute and Debug
Task Result

Connect model calls with the full execution path. Look for redundant input, repeated reasoning and expensive steps, then optimize around successful task completion.

Genesis focuses on the total cost of a successfully completed task, giving optimization a business goal and an analytical basis.

The Genesis Approach

Connect Application Context, Data and Execution

Draw on MatrixOrigin's work in enterprise data, long-term memory and agent runtimes to improve token use across real applications.

01Application Context

Match Models and Calling Strategies to the Task

Different applications need different model capabilities, inputs and execution patterns. Adjust model selection, context organization and calling strategies around the business task to reduce unnecessary consumption.

Choose models for business goals and task requirements
Organize relevant input and reduce redundant context
Review repeated reasoning and calls to refine execution

01
Business Task
Define the work to complete
02
Model and Context
Match capabilities and relevant information
03
Calling Strategy
Reduce unnecessary consumption

Use model capabilities for the task at hand

02Data

Give Models More Accurate, Concise Information

Use MatrixOne, MatrixPipeline and Memoria long-term memory to connect business data, application context and past experience, reducing repeated input and unproductive reasoning.

Ground the current task in business data
Prepare useful context through data processing
Reuse long-term memory and past experience

MatrixOne MatrixPipeline Memoria

01
Business Data and Experience
MatrixOne · Memoria
02
Organize Context
MatrixPipeline
03
Model Input
More accurate, concise information

Reduce repeated input and unproductive reasoning

03Agent Runtime

Connect Token Consumption to Task Steps

Use Astra's agent execution and debugging capabilities to connect model calls with the task process. Help developers analyze usage and identify expensive steps, making costs more transparent and optimization better informed.

Connect model calls with task execution
Analyze token consumption along the execution path
Use runtime and debugging records to find improvements

Explore Astra

01
Task Planning
Break down work around a goal
02
Model Calls
Record consumption in task context
03
Execute and Debug
Identify expensive steps

Explain token spending through execution

From Applications to Compute

Improve Both Consumption and Production

How applications consume tokens and how compute produces them both affect model service efficiency and cost. Genesis pursues improvements on both sides.

Application Side

Reduce Unnecessary Token Consumption

Align calls with business needs by considering application context, enterprise data and agent execution together.

Model selection and calling strategies
Business context and long-term memory
Task execution and debugging analysis

Compute Side

Improve Token Production Efficiency

MatrixOrigin continues to invest in high-performance GPU infrastructure and improve inference, resource scheduling and service efficiency.

Model inference efficiency
Compute resource scheduling
Resource utilization and service efficiency

Ongoing work targets better compute utilization and lower token service costs.

Unified Model Services

Connect Model Access with Usage Management

Access models through one service and manage everyday calls with routing, access controls and usage records.

Unified Model API

Use the OpenAI SDK with language, vision, embedding and reranking capabilities.

Model Routing

Manage upstream channels and calling paths, with policies informed by latency, cost and availability.

Access and Quotas

Manage application access through credentials, quotas, rate limits and expiry dates.

Usage and Costs

See model calls, token consumption and costs together to support ongoing analysis.

Get Started

Start with a Real Business Task

Define the result you need, connect a model, then review consumption alongside context and execution as you iterate.

Start Using Genesis

1
Define the Task
Choose a real scenario and define its expected result and success criteria.
2
Connect Model Services
Open Genesis, prepare credentials, a service URL and an available model, then call with your familiar SDK.
3
Iterate Around the Task
Review repeated input, reasoning and expensive steps alongside data, memory and agent execution.

View an API Integration Example

Python · OpenAI SDK

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GENESIS_API_KEY"],
    base_url=os.environ["GENESIS_BASE_URL"],
)

response = client.chat.completions.create(
    model=os.environ["GENESIS_MODEL"],
    messages=[
        {"role": "user", "content": "Hello, Genesis"}
    ],
)

print(response.choices[0].message.content)

The example reads your actual service URL, credentials and model from environment variables. Keep API keys out of source code.

About Genesis

Why focus on the total cost of a successful task?

Token prices explain only part of the spending. Redundant context, repeated reasoning and complex execution also consume resources. Analyze model calls alongside task results and the execution path to understand whether the spending is productive and where to improve.

How do data, memory and the agent runtime contribute?

MatrixOne, MatrixPipeline and Memoria connect business data, application context and past experience to give models more accurate, concise information. Astra execution and debugging capabilities connect calls with the task process, helping developers analyze token use and expensive steps.

Can I call the Genesis API on its own?

Yes. Applications can access models through the unified API using the OpenAI SDK calling pattern. Teams can also combine MOI data, knowledge and agent capabilities to analyze and improve complete business tasks.

How should teams assess token efficiency?

Start with comparable business tasks and clear success criteria. Review outcomes, token use, repeated inputs and execution paths together. Relate changes in context, model selection and calling strategies to task performance and assess the results over time.