What Kind of Data Does Apache Maka Process? A Complete Guide to Its Data Pipeline

Apache Maka processes nine distinct data categories ranging from lightweight user prompts and session metadata to large binary artifacts, permission hierarchies, and sandbox configuration boundaries.

Apache Maka is a full-stack AI-assistant platform that moves diverse data types through a strictly validated pipeline. Understanding what kind of data Apache Maka process is essential for developers integrating with its runtime host, configuring skills, or auditing its security model. The platform handles everything from conversational text to encrypted credentials while maintaining fail-closed defaults and append-only immutability guarantees.

User Prompts and Conversational Sessions

The primary input to Apache Maka consists of user prompts and conversational turns that initiate or continue AI sessions. These text inputs arrive through a JSON-RPC contract defined in packages/cli/src/acp/README.md, where each request specifies the prompt content and target model.

When a user submits a query, the runtime host creates a durable session record containing the prompt, selected model ID, and timestamps. This data flows through the CLI interface:

// packages/cli/src/acp/README.md (excerpt)
{
  "jsonrpc": "2.0",
  "method": "session.create",
  "params": {
    "prompt": "Write a short poem about clouds.",
    "model": "gpt-4o-mini"
  }
}

The host validates this input against the method schema before writing the session record to its SQLite-backed operational store.

Session and Workspace Metadata

Beyond raw prompts, Apache Maka maintains session lifecycle metadata and workspace state as append-only, immutable records. These durable entries track session creation, continuation, rollback operations, and workspace snapshots including artifact pointers and permission flags.

According to docs/session-todo-lifecycle.md, the runtime host treats these records as the authoritative source for recovery and audit trails. The metadata does not contain user-visible content but rather pointers and state machine transitions that enable reliable replay of complex multi-turn interactions.

Model Catalog and Provider Metadata

The platform relies on static model metadata describing AI capabilities, pricing tiers, and context windows. This data is generated at build time from the public models.dev source and injected into the main process only.

In packages/core/src/model-metadata.generated.ts, the PROVIDER_REGISTRY object contains the canonical list of provider capabilities. Runtime code accesses this through lightweight projections rather than loading the full catalog:

// packages/core/src/model-web-search.ts (excerpt)
import { PROVIDER_REGISTRY } from "./model-metadata.generated";

export function getProviderInfo(id: string) {
  return PROVIDER_REGISTRY[id];
}

The renderer process never receives the complete generated file; it receives only the specific provider metadata required for the current operation, minimizing the attack surface.

Tool Results and Artifact Management

Tool-result payloads represent structured outputs from skills such as web-search, code-execution, or screenshot captures. Apache Maka enforces a strict separation between metadata and large binary payloads to maintain stream performance.

As documented in docs/blogs/log-is-the-runtime.md, oversized results are stored as archived artifacts on disk while only lightweight metadata flows through the model-request stream:

// Artifact placeholder sent to the model
{
  "artifactId": "a1b2c3",
  "size": 452387,
  "sha256": "4e9f…",
  "placeholder": "MAKA-ARTIFACT-PAYLOAD"
}

The runtime host stores the full binary payload in the artifact store, while the model receives a placeholder token that it can use to request the payload later if needed.

Computer-Use Permissions and Security Boundaries

Apache Maka processes granular permission metadata that controls what skills may observe or mutate on the host machine. The platform defines four graded permission levels enumerated in packages/core/src/computer-use.ts:

// packages/core/src/computer-use.ts (excerpt)
export type Permission =
  | "metadata_read"
  | "screenshot_read"
  | "keyboard_mutation"
  | "semantic_mutation";

Each skill's manifest declares its required permission level, and the runtime host validates that the user has explicitly granted it before launching the skill's process. This metadata is checked against the session's permission flags before any computer-use operation executes.

Telemetry, Pricing, and Operational State

The runtime collects telemetry and pricing data used for billing calculations and model-selection decisions. This includes resource usage metrics and cost estimates stored in packages/runtime/src/telemetry/model-pricing.generated.ts.

Additionally, operational-state database entries persist in SQLite to maintain the runtime host's project catalog, session catalog, and resource stores. As described in docs/windows-support.md, this database contains only minimal state required for recovery—specifically excluding any user-visible content or conversation data.

Sandbox and Process Isolation Data

Sandbox configuration metadata defines how processes are isolated using platform-specific mechanisms. Apache Maka handles POSIX sandbox policies, macOS SBPL (Sandbox Profile Language) profiles, and Windows job object constraints.

The sandbox manager in packages/runtime/src/sandbox/README.md records process-tree metadata including process IDs, parent relationships, and exit codes:

// packages/runtime/src/sandbox/README.md (excerpt)
if (process.platform === "darwin") {
  // macOS SBPL sandbox: define filesystem and network policies
} else if (process.platform === "win32") {
  // Windows job object: restrict process tree and job limits
}

This boundary data ensures that skills operate within their declared permission scopes regardless of the underlying operating system.

Security and Credential Metadata

Finally, Apache Maka processes security metadata including non-secret binding identifiers and encrypted credential blobs. The platform handles the lifecycle of credentials—from creation through rotation to revocation—according to the policies defined in docs/skill-catalog-policy.md.

Credential metadata includes binding references and access tokens, while the actual secret material remains encrypted at rest and only decrypted within the secure runtime boundary when a validated skill requires it.

Summary

• Apache Maka processes nine data categories: user prompts, session metadata, model catalogs, tool artifacts, permissions, telemetry, sandbox configs, credentials, and operational state.
• File locations matter: Prompts flow through packages/cli/src/acp/README.md, permissions through packages/core/src/computer-use.ts, and artifacts through the runtime host's append-only log system.
• Security by design: Large payloads become artifact metadata, credentials remain encrypted, and sandbox boundaries are strictly enforced per packages/runtime/src/sandbox/README.md.
• Immutable records: Session and workspace data follows append-only semantics for auditability and reliable replay.
• Minimal exposure: The renderer receives only necessary data projections, while sensitive metadata stays in the main process.

Frequently Asked Questions

Does Apache Maka store user conversation content in its SQLite database?

No. According to docs/windows-support.md, the SQLite operational-state database stores only minimal metadata required for recovery, such as project catalogs and session pointers. User-visible conversation content and large binary payloads are stored separately as artifacts or remain in ephemeral memory, ensuring the database contains no sensitive user data.

How does Apache Maka handle large binary results from tools like screenshots or file uploads?

Apache Maka separates metadata from payloads. As implemented in the runtime host and documented in docs/blogs/log-is-the-runtime.md, large binary results are stored as archived artifacts on disk. Only a lightweight placeholder containing the artifact ID, size, SHA256 hash, and access token flows through the model-request stream, allowing the model to request the full payload only when necessary.

What permission levels can computer-use skills request in Apache Maka?

Computer-use skills can request four graded permissions defined in packages/core/src/computer-use.ts: metadata_read (basic system info), screenshot_read (screen capture), keyboard_mutation (simulated input), and semantic_mutation (high-level UI automation). The runtime host enforces these permissions at process launch and maintains the authority boundary between the desktop main process and renderer.

Where does Apache Maka get its AI model pricing and capability metadata?

The platform generates this metadata at build time from the public models.dev source. The generated file packages/core/src/model-metadata.generated.ts exports PROVIDER_REGISTRY, which contains provider capabilities, pricing, and context windows. Runtime components access this registry through functions like those in packages/core/src/model-web-search.ts, receiving only the specific projections they need rather than the full catalog.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}