# Future Development Plans for Terax AI: Roadmap and Architecture

> Discover Terax AI's future development plans including SSH support inline auto suggestions enhanced theming and AI agent meta orchestration built on a secure Rust and TypeScript architecture

- Repository: [Crynta/terax-ai](https://github.com/crynta/terax-ai)
- Tags: architecture
- Published: 2026-07-06

---

**Terax AI's future development plans include SSH support, inline auto-suggestions, enhanced theming, AI agent meta-orchestration, and granular approval flows, all built atop a secure Rust backend and TypeScript frontend architecture.**

The open-source repository `crynta/terax-ai` maintains a detailed roadmap that governs its evolution as an AI-native terminal (ADE). These plans are documented in the project's [`ROADMAP.md`](https://github.com/crynta/terax-ai/blob/main/ROADMAP.md) and [`TERAX.md`](https://github.com/crynta/terax-ai/blob/main/TERAX.md) files, outlining both immediate feature releases and long-term strategic initiatives. The roadmap emphasizes five core themes: AI as a first-class primitive, lightweight design, terminal-first experience, cross-platform parity, and security-by-default.

## Planned Features for Next Releases

The near-term roadmap focuses on expanding connectivity, intelligence, and customization while maintaining the application's sub-10MB footprint.

### SSH Support and Secure Connectivity

Native SSH integration is planned to extend the Rust PTY module (`src-tauri/src/modules/pty/`) with authentication handlers and known-hosts management. The implementation will introduce new IPC commands such as `ssh_open` and `ssh_auth` in the workspace authorization registry ([`src-tauri/src/modules/workspace.rs`](https://github.com/crynta/terax-ai/blob/main/src-tauri/src/modules/workspace.rs)). Later phases will add SFTP and port forwarding capabilities, maintaining the two-process security model where all OS operations remain sandboxed in Rust.

### Inline Terminal Auto-Suggestions

History-based command suggestions will debut first, with optional AI-powered suggestions following. The feature leverages the `useZoom` and `usePresence` hooks to expose recent command history to the AI subsystem ([`src/modules/ai/lib/agent.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/agent.ts)). The UI layer in [`components/WindowControls.tsx`](https://github.com/crynta/terax-ai/blob/main/components/WindowControls.tsx) will render suggestion overlays without disrupting the terminal's PTY stream.

### Theming and UI Customization

Comprehensive theming will expand [`src/styles/tokens.ts`](https://github.com/crynta/terax-ai/blob/main/src/styles/tokens.ts) and [`src/styles/terminalTheme.ts`](https://github.com/crynta/terax-ai/blob/main/src/styles/terminalTheme.ts) to support new terminal themes, UI accents, and configurable keybindings. The React context defined in [`src/lib/useZoom.ts`](https://github.com/crynta/terax-ai/blob/main/src/lib/useZoom.ts) will distribute these tokens throughout the component tree, enabling runtime theme switching without reloading the webview.

### Editor AI Autocomplete Improvements

Latency reductions and project-aware context will enhance the AI composer ([`src/modules/ai/lib/composer.tsx`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/composer.tsx)). The system will cache project file embeddings locally and tune the `buildLanguageModel` function in [`src/modules/ai/lib/agent.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/agent.ts) to leverage local inference when available, reducing round-trip times for code completion.

### Drag-and-Drop Integration

File drops into the terminal will automatically quote paths, while dragging AI panel context will trigger file operations. The terminal UI ([`src/components/WindowControls.tsx`](https://github.com/crynta/terax-ai/blob/main/src/components/WindowControls.tsx)) will implement HTML5 drag-and-drop listeners that invoke the `fs_create_file` and `fs_read_file` Rust commands via Tauri's `invoke` bridge.

### AI Agent Meta-Orchestration

Support for spawning external coding agents (Claude Code, OpenCode) will be added through the agent registry ([`src/modules/ai/agents/registry.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/agents/registry.ts)). New sub-agent definitions will integrate with hooks in [`src-tauri/src/modules/agent.rs`](https://github.com/crynta/terax-ai/blob/main/src-tauri/src/modules/agent.rs), exposing the `agent_spawn_subagent` IPC command to the frontend.

### Expanded Slash Commands and Skills

The tool registry ([`src/modules/ai/tools/tools.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/tools/tools.ts)) will gain additional built-in functions such as `debug`, `test`, and `refactor`. Each new tool will respect the existing approval flow defined in `src/modules/ai/tools/`, ensuring mutating operations require explicit user consent.

### Approval Flow Enhancements

Granular permission policies will allow YOLO/auto-approve modes, project-scoped policies, and per-tool trust levels. The approval UI component will read policies from the settings store ([`src/modules/settings/store.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/settings/store.ts)), while Rust-side enforcement will utilize the [`security.ts`](https://github.com/crynta/terax-ai/blob/main/security.ts) deny-list logic.

### Persistent Sessions and Layout Restore

Session persistence via [`src/modules/ai/lib/sessions.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/sessions.ts) currently stores chat history in [`terax-ai-sessions.json`](https://github.com/crynta/terax-ai/blob/main/terax-ai-sessions.json) using `tauri-plugin-store`. Future updates will serialize entire workspace layouts—including tabs, panes, and working directories—enabling full state restoration between launches.

### Preview Surface Expansion

Rich media handling will improve for images, Markdown, and PDFs. The preview iframe in [`src/components/WindowControls.tsx`](https://github.com/crynta/terax-ai/blob/main/src/components/WindowControls.tsx) will integrate with the sandboxed renderer (`src/modules/preview/`) to handle additional MIME types safely.

## Long-Term Strategic Goals

Beyond immediate releases, the [`ROADMAP.md`](https://github.com/crynta/terax-ai/blob/main/ROADMAP.md) outlines architectural initiatives to ensure scalability and performance.

- **Release Automation**: Streamlined changelog generation, version bumping, and tag flows to maintain rapid iteration cycles.
- **Bundle Optimization**: Lazy-loading language packs and tree-shaking UI primitives to keep binaries under 10MB.
- **Selective TypeScript to Rust Migration**: Profiling-driven rewrites of PTY I/O bottlenecks from TypeScript to Rust for native performance.
- **Plugin Architecture**: Installable AI tool/skill bundles enabling community extensions while preserving the narrow, security-focused scope.
- **Live Filesystem Updates**: Real-time explorer and editor synchronization with external filesystem changes (e.g., Git operations).

## Architectural Foundations Enabling the Roadmap

The future development plans for Terax AI leverage a deliberate two-process architecture that separates OS-level operations from the webview UI.

**Two-Process Security Model**: All PTY, filesystem, network, and secret operations reside in the Rust backend (`src-tauri/src/modules/`). Adding functionality requires defining a new Tauri command in Rust and exposing a typed wrapper to the webview, as documented in [`docs/architecture/two-process-model.md`](https://github.com/crynta/terax-ai/blob/main/docs/architecture/two-process-model.md).

**AI Subsystem Extensibility**: Built on Vercel's AI SDK ([`src/modules/ai/lib/agent.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/agent.ts)), the system supports adding providers, tools, and sub-agents through the patterns documented in [`docs/architecture/ai-subsystem.md`](https://github.com/crynta/terax-ai/blob/main/docs/architecture/ai-subsystem.md). The `buildTools` function automatically wires new capabilities into streaming requests.

**Tool Approval Guardrails**: Mutating tools (`write_file`, `edit`, `bash_run`) automatically pause LLM streams and render approval cards. This safety mechanism spans the React UI ([`src/components/WindowControls.tsx`](https://github.com/crynta/terax-ai/blob/main/src/components/WindowControls.tsx)), TypeScript guards (`src/modules/ai/tools/`), and Rust filesystem modules (`src-tauri/src/modules/fs/`).

**Session Persistence**: The `tauri-plugin-store` implementation in [`src/modules/ai/lib/sessions.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/sessions.ts) provides the foundation for saving not just conversation history, but complete workspace states.

## Implementation Examples

### Running the AI Agent

The current `runAgentStream` function in [`src/modules/ai/lib/agent.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/agent.ts) (lines 91-99) orchestrates LLM interactions:

```typescript
import { runAgentStream } from "./src/modules/ai/lib/agent";
import { buildTools } from "./src/modules/ai/tools/tools";

const uiMessages = [
  { role: "user", content: "Create a new React component called HelloWorld." },
];

const toolContext = {
  // filesystem, git, shell services injected here
};

runAgentStream({
  keys: {},                 // API keys from OS keychain
  uiMessages,
  toolContext,
  onStep: (label) => console.log("Step:", label),
  onUsage: (delta) => console.log("Usage:", delta),
  onFinishMeta: (info) => console.log("Finished:", info),
});

```

### Adding a New AI Tool

To extend the agent's capabilities, modify [`src/modules/ai/tools/tools.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/tools/tools.ts):

```typescript
export function buildTools(ctx: ToolContext) {
  const base = [
    // existing tools...
  ];

  const searchSO = {
    name: "search_stackoverflow",
    description: "Search StackOverflow for relevant Q&A.",
    parameters: {
      type: "object",
      properties: { query: { type: "string" } },
      required: ["query"],
    },
    async execute({ query }: { query: string }) {
      const resp = await fetch(
        `https://api.stackexchange.com/2.3/search/advanced?order=desc&sort=relevance&site=stackoverflow&q=${encodeURIComponent(query)}`
      );
      const data = await resp.json();
      return JSON.stringify(data.items.slice(0, 3));
    },
  };

  return [...base, searchSO];
}

```

### Registering Rust IPC Commands

New backend capabilities, such as SSH support, require Rust command registration in [`src-tauri/src/lib.rs`](https://github.com/crynta/terax-ai/blob/main/src-tauri/src/lib.rs):

```rust
// src-tauri/src/modules/ssh/mod.rs
#[tauri::command]
pub async fn ssh_open(host: String, user: String) -> Result<String, String> {
    // Spawn SSH PTY session, store handle, return session ID
    Ok("session_id".to_string())
}

// In src-tauri/src/lib.rs
tauri::generate_handler![..., ssh_open];

```

The frontend invokes this via `invoke("ssh_open", { host, user })` from a corresponding TypeScript wrapper.

## Summary

- **Immediate priorities** include SSH integration, inline auto-suggestions, and theming, all extending the existing Rust/TypeScript architecture.
- **Security** remains central: new features leverage the two-process model, with mutating AI tools requiring approval through the flow defined in `src/modules/ai/tools/`.
- **Extensibility** is built-in: adding tools requires updating [`src/modules/ai/tools/tools.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/tools/tools.ts), while new OS features need only a Rust command handler and JS wrapper.
- **Persistence** capabilities in [`src/modules/ai/lib/sessions.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/lib/sessions.ts) will expand to support full workspace restoration.
- **Long-term** initiatives target release automation, bundle optimization, and selective Rust migration to maintain performance and the sub-10MB footprint.

## Frequently Asked Questions

### What is the next major feature coming to Terax AI?

SSH support is the next major connectivity feature on the roadmap. According to the [`ROADMAP.md`](https://github.com/crynta/terax-ai/blob/main/ROADMAP.md) in the `crynta/terax-ai` repository, this will extend the Rust PTY module (`src-tauri/src/modules/pty/`) with new IPC commands like `ssh_open` and `ssh_auth`, followed by SFTP and port forwarding capabilities.

### How does Terax AI plan to handle AI safety and permissions?

Future development includes granular approval flow enhancements allowing YOLO/auto-approve modes, project-scoped policies, and per-tool trust levels. The approval UI reads from [`src/modules/settings/store.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/settings/store.ts), while enforcement utilizes Rust-side security checks in the two-process architecture, ensuring no AI tool executes mutating operations without explicit user consent.

### Will Terax AI support plugins or extensions?

The long-term roadmap includes an architecture for AI tool/skill bundles as installable plugins. These will enable community-driven extensions while maintaining the project's narrow, security-focused scope. Currently, extensibility is achieved by adding tools to [`src/modules/ai/tools/tools.ts`](https://github.com/crynta/terax-ai/blob/main/src/modules/ai/tools/tools.ts) and registering new IPC commands in [`src-tauri/src/lib.rs`](https://github.com/crynta/terax-ai/blob/main/src-tauri/src/lib.rs).

### How will Terax AI maintain its lightweight footprint while adding features?

The roadmap prioritizes bundle optimization through lazy-loaded language packs, tree-shaking UI primitives, and selective migration of performance-critical TypeScript code to Rust. The explicit goal is keeping the binary size under 10MB, as outlined in the "Lightweight always" theme of the project documentation.