kenzoAI Platform Model

kenzoAI is a multi-tenant, AI service layer designed to integrate intelligence capabilities into existing systems. kenzoAI functions as the AI service layer, while all configuration, access, and monitoring activities are managed through the kenzoAI Developer Portal.

The platform model explains how resources are structured, how usage is measured, and how limits and permissions are enforced across the system. Understanding this model helps teams design scalable integrations, apply effective governance, and operate kenzoAI reliably in enterprise environments.

AI Model Tiers

kenzoAI offers three AI model quality tiers. The model can be selected per request or configured as a default in the Developer Portal.

Tier	Model	Free Tier Access	Paid Tier Access
Best	Claude Sonnet 4.6	Yes	Yes
Optimized	Claude Haiku 4.5	Yes	Yes
Economy	GPT-5.6 Luna	Yes	Yes

note

The Free Tier supports up to 3 App keys (maximum apps) with 7 days of audit log retention, while the Paid Tier supports up to 100 App keys with 90 days of audit log retention.

Credit-Based Usage and Metering

kenzoAI operates on a credit-based usage model that measures actual consumption of AI-powered capabilities across the platform. Credits represent the cost of analyzing recent code changes, evaluating build configurations, interpreting build logs, and generating insights or recommendations.

Usage is metered dynamically based on the volume, type, and complexity of data processed, rather than fixed limits or reserved capacity. Credits are deducted as AI operations are executed, ensuring usage aligns directly with real platform activity.

Benefits of Credit-Based Model

This usage model enables:

• Accurate alignment between usage and billing
• Clear visibility into which operations consume the most resources
• Better cost control and capacity planning

By metering actual AI activity instead of abstract limits, kenzoAI helps teams understand and manage usage while maintaining predictable operational costs.

Credit Allocation Model

kenzoAI uses a two-level credit control model:

• Account-Level Credit Pool: When credits are granted or purchased, they are added to the account’s active credit pool, which represents the total available credits for the billing period.
• Application-Level Credit Limits: Each application defines a maximum credit limit that controls how many credits the app is allowed to consume from the total pool.

This structure enables centralized cost control while allowing teams to isolate and manage usage at the application level.

How Credit Consumption Works

When an application invokes kenzoAI capabilities:

• Credit consumption is metered against the application’s configured credit limit, and the same credits are deducted from the total account-level credit pool.
• Credit consumption occurs per AI operation and reflects backend processing rather than user interface actions.

AI operations may be restricted or fail if:

• The application reaches its configured Max Credits.
  Solution: Increase the application's Max Credits or manually reset the application's consumed credits for the current reset cycle.
• The account-level credit pool is exhausted.
  Solution: Purchase an additional credit pack.
• Too many concurrent requests are sent from the user account, potentially exceeding the credits remaining in the current account-level credit pool.
  Solution: Wait for the current requests to complete, then retry the operation. To prevent this issue, implement client-side throttling or reduce request concurrency.

How Usage Is Measured

Credit usage is recorded whenever an AI operation is triggered through the platform. These operations may include actions such as:

• Analyzing build logs
• Explaining or evaluating build configurations
• Analyzing recent code changes to predict failure likelihood

Usage events are system-generated and reflect backend AI processing rather than direct user interface actions. Each usage event captures details such as:

• Total credits consumed by the operation
• Type of AI operation performed
• Associated application (App Key) whose credentials are used for the request
• Message type of the request
• Session ID of the request
• Model tier used for the request

Metering occurs continuously and reflects near-real-time consumption, providing an accurate view of platform usage.

Free Tier and Credit Grant

Each eligible new GrapeHub customer account receives a one-time free grant of kenzoAI credits. The grant credits are added to the account's credit balance automatically after signing up for the first time and are attached to that GrapeHub account.

• The free grant is available once per account.
• Grant credits can be used across all three model tiers: Economy, Optimized, and Best.
• Grant credits are valid for one year from the date they're added.
• Grant credits cannot be transferred, refunded, exchanged for cash, or renewed.
• Audit log retention is limited to 7 days while the account remains on the free tier.

note

For more information about available credit packs, pricing, and one-time free grant, see BuildNinja Pricing.

Credit Packs

kenzoAI does not use named plans or subscription tiers. Users purchase credits directly and they are added to the running balance.

• Any GrapeHub user can purchase a credit pack
• Available credit packs are 2.5M credits, 7M credits, and 15M credits
• Unused credits roll over when a new pack is purchased
• Credit packs are valid for one year
• Purchasing a credit pack provides 90 days of audit log retention

note

For more information about available credit packs, pricing, and one-time free grant, see BuildNinja Pricing.

Overage Credits Behavior

If a request consumes more credits than are available in the account-level credit pool, the excess usage is recorded as overage credits. Any outstanding overage is automatically deducted from newly purchased credits before they become available for normal consumption.

When the available credit balance reaches zero, subsequent inference-related API requests are blocked until additional credits are purchased. Regularly monitoring the credit balance through the OverviewThe kenzoAI Developer Portal Overview provides a centralized view of your account's credit usage and application activity. helps prevent unexpected service interruptions.

Resetting Application Credit Limits

Application credit limits can be reset automatically or manually, depending on configuration. Important behavior to note:

• Resetting an application’s credit limit restores only the application-level allowance.
• Credits already consumed from the account-level pool are not restored.
• Credits deducted from the pool are permanently consumed for the billing period.

This separation ensures that application-level controls do not override actual usage-based billing.

note

For more information on manually resetting application credit limits, see Reset ConsumptionResetting consumption clears the recorded consumed credits for an application without deleting the application or changing its credentials..

Usage Logging and Visibility

kenzoAI logs all credit allocation and consumption events to ensure billing accuracy, cost transparency, and usage analysis. The platform provides:

• Per-application credit usage tracking
• Per-operation usage breakdowns
• Aggregated usage views (daily, weekly, and monthly)
• Visibility into remaining and consumed credits

Usage data is stored and made available through Usage analytics tab for reporting and reconciliation.

App Keys and App Secrets

Access to kenzoAI is managed using application-level credentials generated when an application is created. The maximum number of applications (App keys) permitted per account is:

Tier	Maximum Applications
Free	3
Paid	100

App Key

The App Key uniquely identifies the calling application or integration. It is used to:

• Identify the application making requests to kenzoAI
• Attribute credit usage and analysis to a specific app
• Enable per-application usage tracking and analytics

The App key must be included with every API request.

App Secret

The App Secret is a confidential credential used alongside the App key to authenticate requests securely. App Secrets must be handled carefully:

• Keep App Secrets private at all times.
• Do not commit secrets to source code repositories.
• Do not expose secrets in client-side or browser-based applications.
• Store secrets securely using environment variables or a secrets manager.

If an App Secret is compromised, it can lead to unauthorized access and unintended credit consumption.

Credential Pairing and Access Control

kenzoAI validates requests using the App Key and App Secret together. This pairing ensures that:

• Requests are both identifiable (App Key) and authenticated (App Secret)
• Usage is accurately attributed to the correct application
• Access remains secure, traceable, limited, and auditable

Rate Limits and Quotas

kenzoAI enforces rate limits and usage quotas to maintain platform stability, prevent abuse, and ensure fair usage across all customers.

Rate Limits

kenzoAI applies rate limits to control the frequency of requests across different access surfaces. These limits help ensure consistent performance and protect the platform from excessive or abusive traffic.

Rate limits are enforced independently for each surface, with the enforcement scope varying by access type.

Surface	Interval	Limit
Developer Portal	Per second	5 requests
	Per hour	100 requests
	Per day	500 requests
kenzoAI API (per App key)	Per second	10 requests
	Per hour	300 requests
	Per day	500 requests
Model Tiers API (per IP address)	Per second	5,000 requests
	Per hour	5,000 requests
	Per day	5,000 requests

note

For the Model Tiers API, IP addresses are used solely to enforce rate limits. They are not used to identify individual users or to associate requests with a specific user account.

Requests that exceed the configured rate limit receive an HTTP 429 (Too Many Requests) response, along with a Retry-After header indicating when requests may resume.

Rate limit values are managed by the platform and may change over time. Always rely on API responses or official platform communications for the most up-to-date limits.

Usage Quotas

Usage quotas are governed by the available credit balance described in Credit-Based Usage and Metering and Overage Credits Behavior. Once the available credits are exhausted, AI operations are blocked until additional credits are purchased.

Enforcement Scope

Rate limits and usage quotas are enforced at different scopes based on the access surface:

• Developer Portal enforcement is applied per user or account, ensuring fair and stable access to administrative and management operations.
• kenzoAI API enforcement is applied per application (App key), allowing teams to isolate usage, apply governance controls, and manage consumption independently across integrations, environments, and workloads.
• Model Tiers API enforcement is applied per IP address to protect shared inference infrastructure and prevent traffic saturation at the network level.

This layered enforcement approach provides strong runtime isolation for AI workloads while maintaining reliability, security, and fairness across all platform access points.