Future Development Plans for Terax AI: Roadmap and Architecture

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 and 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). 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). The UI layer in 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 and src/styles/terminalTheme.ts to support new terminal themes, UI accents, and configurable keybindings. The React context defined in 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). The system will cache project file embeddings locally and tune the buildLanguageModel function in 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) 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). New sub-agent definitions will integrate with hooks in 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) 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), while Rust-side enforcement will utilize the security.ts deny-list logic.

Persistent Sessions and Layout Restore

Session persistence via src/modules/ai/lib/sessions.ts currently stores chat history in 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 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 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.

AI Subsystem Extensibility: Built on Vercel's AI SDK (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. 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), 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 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 (lines 91-99) orchestrates LLM interactions:

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:

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:

// 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, while new OS features need only a Rust command handler and JS wrapper.
• Persistence capabilities in 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 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, 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 and registering new IPC commands in 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.

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