# Does holaOS Support Code Generation? AI-Driven Development Guide

> Discover how holaOS enables AI driven code generation with OpenAI Codex and Claude Code. Learn how MCP integrates CLI tools and inserts generated files directly into your workspace.

- Repository: [holaboss.ai/holaOS](https://github.com/holaboss-ai/holaOS)
- Tags: how-to-guide
- Published: 2026-08-15

---

**Yes, holaOS supports native AI-driven code generation through dedicated harnesses for OpenAI Codex and Claude-Code, integrated via the Model Context Protocol (MCP) to spawn CLI tools and automatically insert generated files into workspaces.**

holaOS, developed by holaboss-ai, is an open-source runtime environment designed for autonomous AI agents. The platform includes built-in **holaOS code generation** capabilities that allow agents to write, refactor, and manage source code using state-of-the-art large language models without leaving the workspace environment.

## How holaOS Implements Code Generation

The platform implements code generation through a dual-harness architecture that wraps popular AI coding assistants and exposes them as standardized tools through the Model Context Protocol.

### The Codex and Claude-Code Harnesses

holaOS defines dedicated harnesses in [`runtime/harnesses/src/codex.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/harnesses/src/codex.ts) and [`runtime/harnesses/src/claude-code.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/harnesses/src/claude-code.ts) that register the code-generation models. The **Codex harness** (`codexHarnessDefinition`) launches the `run-codex` CLI command and establishes a bidirectional JSON-RPC protocol, registering the `gpt-5.3-codex` model. Similarly, the **Claude-Code harness** (`claudeCodeHarnessDefinition`) spawns the Claude-Code binary and exposes its `/v1/completions` endpoint.

### Runtime Integration via MCP

The system integrates these harnesses into the agent toolchain through two critical server components. [`runtime/api-server/src/runtime-agent-tools.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/api-server/src/runtime-agent-tools.ts) imports the harness functions (such as `runCodex`) and adds them to the agent-level toolset. Then, [`runtime/api-server/src/runtime-tools-mcp.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/api-server/src/runtime-tools-mcp.ts) registers the `code_generate` capability, mapping tool IDs like `codex_generate` to HTTP routes (e.g., `/api/v1/capabilities/runtime-tools/codex/generate`). This MCP layer handles authentication, model selection, and result parsing, making the models available as callable tools within any workspace.

## Using holaOS Code Generation Features

Developers and agents can request code generation through either the TypeScript MCP client or direct REST API calls.

### Generating Code with the Codex Harness

The MCP client provides a typed interface for requesting TypeScript, Python, or other language outputs:

```typescript
import { createMcpClient } from '@/utils/mcp-client';

// Initialise an MCP client for the current workspace
const mcp = await createMcpClient({ workspaceId: 'my-ws' });

// Call the Codex code-generation endpoint
const result = await mcp.callTool('codex_generate', {
  // Prompt describing the desired code
  prompt: `Write a TypeScript function that returns the nth Fibonacci number.`,
  // Optional model selection; defaults to the first registered model
  model: 'gpt-5.3-codex',
  // Desired filename (the runtime will write the file automatically)
  filename: 'fib.ts',
});

console.log('Generated file:', result.file_path);
// → "/workspace/my-ws/fib.ts"

```

This call routes through [`runtime-tools-mcp.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime-tools-mcp.ts), which translates the tool ID `codex_generate` into the internal `runCodex` implementation.

### Generating Code with Claude-Code

To use the alternative Claude-Code harness, call the corresponding tool ID:

```typescript
const result = await mcp.callTool('claude_code_generate', {
  prompt: `Create a Python script that reads a CSV file and prints the sum of a column called "price".`,
  model: 'claude-3-5-sonnet',   // model name taken from the harness definition
  filename: 'sum_prices.py',
});

console.log(result.file_path); // → "/workspace/my-ws/sum_prices.py"

```

### REST API Integration

External services can bypass the MCP client and call the generation endpoint directly:

```bash
curl -X POST https://hola.example.com/api/v1/capabilities/runtime-tools/codex/generate \
  -H 'Content-Type: application/json' \
  -d '{
        "prompt":"Write a Rust function that computes the factorial of n.",
        "filename":"factorial.rs"
      }'

```

The endpoint returns file metadata and a download URL, allowing non-TypeScript services to leverage holaOS code generation capabilities.

## Key Source Files and Architecture

Understanding the following files is essential for customizing or debugging the code generation pipeline:

- **[`runtime/harnesses/src/codex.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/harnesses/src/codex.ts)** – Defines the Codex harness, registers the `gpt-5.3-codex` model list, and manages the CLI lifecycle.
- **[`runtime/harnesses/src/claude-code.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/harnesses/src/claude-code.ts)** – Defines the Claude-Code harness and its model configuration.
- **[`runtime/api-server/src/runtime-agent-tools.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/api-server/src/runtime-agent-tools.ts)** – Imports harness functions (`runCodex`, `runClaudeCode`) and registers them as agent-level tools.
- **[`runtime/api-server/src/runtime-tools-mcp.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/api-server/src/runtime-tools-mcp.ts)** – Maps tool IDs to HTTP routes and handles MCP protocol translation for `codex_generate` and `claude_code_generate`.
- **[`runtime/harness-host/src/harness-registry.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/harness-host/src/harness-registry.ts)** – Discovers and registers all harnesses at runtime, making them available to the MCP server.

Together, these components enable holaOS to generate source code on-the-fly, insert files directly into the workspace file system, and iterate on code through subsequent AI tool calls.

## Summary

- **holaOS code generation** is natively supported through dedicated harnesses for OpenAI Codex and Claude-Code.
- The system uses the **Model Context Protocol (MCP)** to expose generation models as callable tools within agent workspaces.
- Generated files are automatically written to the workspace file system, enabling immediate use by linters, test runners, and other tools.
- Both programmatic TypeScript clients and standard REST APIs are supported for requesting code generation.

## Frequently Asked Questions

### Does holaOS support code generation natively?

Yes. According to the holaboss-ai/holaOS source code, code generation is a core platform capability implemented through first-party harnesses in [`runtime/harnesses/src/codex.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/harnesses/src/codex.ts) and [`runtime/harnesses/src/claude-code.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/harnesses/src/claude-code.ts), not through third-party plugins or external integrations.

### Which AI models does holaOS use for code generation?

The platform currently supports **OpenAI Codex** (specifically the `gpt-5.3-codex` model) and **Claude-Code** (using models like `claude-3-5-sonnet`). These are registered via harness definitions and can be selected by name when calling the generation tools.

### How does holaOS integrate generated code into workspaces?

When a generation request is processed through [`runtime/api-server/src/runtime-agent-tools.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/api-server/src/runtime-agent-tools.ts), the resulting code is returned as a JSON object containing a `file_path`. The runtime automatically writes this content to the specified location within the workspace file system, making it immediately available for editing or execution.

### Can external services use holaOS code generation via API?

Yes. The system exposes REST endpoints such as `/api/v1/capabilities/runtime-tools/codex/generate` defined in [`runtime-tools-mcp.ts`](https://github.com/holaboss-ai/holaOS/blob/main/runtime-tools-mcp.ts). External services can authenticate via standard headers and request code generation using JSON payloads without requiring the TypeScript MCP client.