PhoneWhisper Autonomous Datacenter Documentation

Direct sensor readouts polled from the physical Xiaomi Redmi 9i handset (/sys/class/thermal, /sys/devices/system/cpu, /proc/meminfo).

Architecture Overview & Guarantees

PhoneWhisper transforms low-cost consumer smartphone hardware into an enterprise-grade AI micro-datacenter. The architecture addresses three fundamental tenets: zero cloud subscription costs, multi-modal edge execution, and complete developer sovereignty over model weights and private data.

Test real inference requests directly from your browser against the live datacenter node. Audio is processed via Piper VITS TTS and Whisper Base.en STT running on ARM silicon.

{"status": "ready", "instruction": "Click 'Start Mic Recording' or 'Run Built-in Sample WAV' to test Whisper Base.en ASR"}

Execute a 5-phase live hardware benchmark test against the MediaTek Helio G25 node to profile L1 RAM throughput, vector dot products, neural vocoder RTF, and SQLite WAL write speeds.

Construct and execute arbitrary HTTP requests directly against any datacenter endpoint. Inspect live response codes, timing metrics, and response headers in real time.

Inspect acoustic features in real time. Whisper Base.en transforms raw audio signals into 80-channel log mel-filterbank representations using 25ms STFT windows and 10ms hop steps.

Direct terminal emulator connected to the Xiaomi Redmi 9i ARM64 environment. Run diagnostic commands to query real-time hardware telemetry, execute network pings, inspect the process table, and audit SQLite WAL state.

Deep microsecond-level timing waterfall tracing a single request from the global Cloudflare Anycast edge through the reverse proxy, Python 3.11 epoll dispatch, ARM NEON Int8 tensor execution, and SQLite WAL sync.

Generate strictly typed data structures for all PhoneWhisper payloads in TypeScript, Python Pydantic v2, Go structs, and Rust Serde types.

Profile input prompt lengths, estimate BPE token counts, and calculate KV-cache memory allocation on the Helio G25 ARM64 CPU.

Adjust runtime hyper-parameters with live visual sliders to generate valid JSON payloads and pre-formatted cURL terminal commands.

Every Swades autonomous agent event and asynchronous task emits cryptographic webhooks signed with an HMAC-SHA256 digest in the X-Hub-Signature-256 HTTP header.

Validate arbitrary JSON payloads against official OpenAPI 3.1.0 specifications for Chat, Audio Speech, and Agent tasks before sending them to the edge server.

Compare total cost of ownership (TCO) across physical smartphone micro-datacenters versus hyperscaler cloud providers (AWS, OpenAI Whisper API, ElevenLabs, Anthropic).

Begin issuing requests immediately. All multi-modal AI endpoints are public and require zero API key headers or authentication setup.

curl -X POST https://phone-whisper-server.pages.dev/v1/audio/transcriptions \
  -F "file=@sample.wav" \
  -F "model=whisper-base-en" \
  -F "response_format=json"

curl -X POST https://phone-whisper-server.pages.dev/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{"model": "piper", "input": "Helio G25 edge synthesis active.", "voice": "amy"}' \
  --output output.wav

curl -N -X POST https://phone-whisper-server.pages.dev/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openrouter/free",
    "messages": [{"role": "user", "content": "Explain write-ahead logging in 2 sentences."}],
    "stream": true
  }'

Click on any architectural tier below to inspect ingress protocols, buffer management, security boundaries, and hardware execution paths.

Trace packets through every tier of the datacenter stack in real time. Choose a pipeline to watch packets flow through network sockets, kernel memory buffers, and SIMD registers.

Simulate adverse edge datacenter failure scenarios to verify automatic governor scaling, rate limiter shielding, and zero-downtime model fallbacks.

Physical Node Hardware Specifications

The physical compute node is a dedicated Xiaomi Redmi 9i handset configured as an autonomous headless datacenter blade. Battery health is maintained at 25°C via active convective heat sinks.

Linux Thermal Governor & Elastic Memory Management

Consumer smartphone operating systems are aggressive at killing background processes via the Android Low Memory Killer (LMK). PhoneWhisper overrides default Linux kernel scheduler rules to preserve gateway resilience.

# Query CPU frequencies across all 8 cores
cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_cur_freq

# Force performance governor on Cortex-A53 cluster 0
echo performance > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor

# Set OOM score adjustment to unkillable priority
echo -1000 > /proc/$(pgrep -f gateway.py)/oom_score_adj

# Audit memory swap statistics
cat /proc/swaps

Alpine PRoot Distro Virtualization Runtime

To run unprivileged containerized environments without requiring Android root privileges, PhoneWhisper uses proot-distro. This provides a clean POSIX root filesystem running Alpine Linux 3.19.

# Launching worker directly into isolated PRoot namespace:
proot-distro login alpine -- node /root/Swades-Agent/worker.js --job job_a9f8224f

Multi-Modal AI Inference Engines

PhoneWhisper deploys 5 specialized lightweight neural networks optimized specifically for ARM Cortex-A53 NEON SIMD vector hardware registers.

Sub-Microsecond Storage & Data Layer

Object storage on PhoneWhisper bypasses legacy network file abstractions in favor of in-process RAM caching combined with SQLite Write-Ahead Logging (WAL) on local flash storage.

Security Shield, Authentication & Concurrency

The node is protected by three defense-in-depth layers: SwadesSecurityShield rate limiters, PBKDF2 cryptographic authentication, and SQLite WAL ACID transaction locks.

Detailed technical reference for all 11 gateway endpoints, complete with headers, query parameters, multipart payloads, status codes, and schema definitions.

{
  "text": "Hello, this is a live transcription running on Helio G25 physical silicon.",
  "language": "english",
  "duration": 4.12,
  "inference_time_ms": 284.15
}

{
  "model": "openrouter/free",
  "messages": [
    {"role": "system", "content": "You are a concise datacenter assistant."},
    {"role": "user", "content": "What is the CPU of this server?"}
  ],
  "temperature": 0.7,
  "max_tokens": 1024,
  "stream": false
}

{
  "id": "chatcmpl-91a0b3c4",
  "object": "chat.completion",
  "created": 1788523000,
  "model": "openrouter/free",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "This server is powered by a MediaTek Helio G25 octa-core ARM Cortex-A53 processor running inside a physical Xiaomi Redmi 9i smartphone."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 28,
    "completion_tokens": 32,
    "total_tokens": 60
  }
}

{
  "input": "Welcome to earth!",
  "voice": "amy",
  "speed": 1.0,
  "response_format": "wav"
}

GET /v1/audio/speech?input=Welcome+to+earth!&voice=amy

<!-- HTML5 Native Player -->
<audio src="/v1/audio/speech?input=Welcome+to+earth!&voice=amy" controls></audio>

{
  "status": "success",
  "voices": [
    { "id": "amy", "name": "Amy (English Female • Natural VITS)", "language": "en-US", "gender": "female", "sample_rate": 22050 },
    { "id": "lessac", "name": "Lessac (English Male • Resonant VITS)", "language": "en-US", "gender": "male", "sample_rate": 22050 }
  ],
  "total": 2,
  "engine": "Piper VITS Neural Model (VITS Architecture)",
  "sample_rate": 22050
}

{
  "model": "all-MiniLM-L6-v2",
  "input": "Edge computing on mobile hardware"
}

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "index": 0,
      "embedding": [-0.0241, 0.0812, -0.0194, 0.0435, "... 384 floats total"]
    }
  ],
  "model": "all-MiniLM-L6-v2",
  "usage": {"prompt_tokens": 6, "total_tokens": 6}
}

{
  "query": "What is the CPU of this phone?",
  "documents": [
    "The node runs on MediaTek Helio G25 octa-core ARM64.",
    "Cloudflare worker serves static frontend assets.",
    "SQLite WAL mode is enabled for L1 storage."
  ],
  "top_n": 2
}

{
  "repo_url": "Electroiscoding/phone-whisper-server",
  "task": "Add dark mode toggle and unit tests for auth module",
  "github_token": "ghp_optionalTokenForPullRequests"
}

{
  "status": "queued",
  "job_id": "job_9a717658_20260904",
  "stream_url": "/v1/agent/stream/job_9a717658_20260904",
  "logs_url": "/v1/agent/logs/job_9a717658_20260904"
}

event: diff_update
data: {"job_id":"job_9a717658","patch":"--- a/auth.js\n+++ b/auth.js\n@@ -1,5 +1,6 @@\n+// Dark mode token support\n"}

event: verification
data: {"job_id":"job_9a717658","passed":true,"compiler":"node --check","errors":[]}

// Request POST /v1/storage/auth/login
{"username": "YOUR_USERNAME", "password": "YOUR_PASSWORD"}

// Response 200 OK
{
  "token": "tok_04f8224f44a1c0520a1f30dc14",
  "expires_in": 86400,
  "user": {"id": "usr_", "username": "YOUR_USERNAME", "role": "developer"}
}

curl -X POST "https://phone-whisper-server.pages.dev/v1/compress" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"data": "High speed sensor telemetry payload", "level": 1}'

{
  "status": "success",
  "engine": "Zstandard v1.5.7 (ARM Cortex-A53 Native)",
  "level": 1,
  "threads": 4,
  "original_size": 35,
  "compressed_size": 42,
  "compression_ratio": 0.83,
  "space_saved_percent": -20.0,
  "elapsed_ms": 1.28,
  "throughput_mb_s": 0.1,
  "compressed_base64": "KLUv/SA8QgAA..."
}

curl -X POST "https://phone-whisper-server.pages.dev/v1/decompress" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"data": "KLUv/SA8QgAA..."}'

curl -s "https://phone-whisper-server.pages.dev/v1/zstd/info"

curl -X POST "https://phone-whisper-server.pages.dev/v1/images/compress" \
  -H "Content-Type: application/octet-stream" \
  --data-binary "@photo.png" \
  -o "photo.png.zst"

curl -X POST "https://phone-whisper-server.pages.dev/v1/images/compress" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"image": "iVBORw0KGgoAAAANSUhEUgAA...", "as_json": true}'

{
  "status": "success",
  "engine": "Zstandard v1.5.7 (ARM Cortex-A53 Native 4T)",
  "compression_algorithm": "zstd",
  "tier": "api",
  "level": 1,
  "original_size": 128450,
  "compressed_size": 42100,
  "compression_ratio": 3.05,
  "space_saved_percent": 67.2,
  "elapsed_ms": 0.65,
  "throughput_mb_s": 192.4,
  "compressed_base64": "KLUv/SBwUQA...",
  "data_url": "data:application/zstd;base64,KLUv/SBwUQA..."
}

curl -s "https://phone-whisper-server.pages.dev/v1/images/info"

from swades import Swades

client = Swades()
# 1-line Zstd image compression (Level 1 -1 -T4):
compressed_bytes = client.compress_image("photo.png")
recovered_bytes = client.decompress_image(compressed_bytes)

import { Swades } from './swades.js';

const client = Swades.init();
const zstdBytes = await client.images.compress(imageUint8Array);
const restoredBytes = await client.images.decompress(zstdBytes);

curl -s "https://phone-whisper-server.pages.dev/v1/acc/info"

{
  "status": "success",
  "engine": "Advanced Charging Controller (ACC)",
  "version": "v2026.9.1",
  "enabled": true,
  "mode": "hybrid_hardware_acc",
  "charging_state": "charging",
  "battery": {
    "level": 78,
    "temperature_c": 32.3,
    "voltage_mv": 3810,
    "health": "Good"
  },
  "thresholds": {
    "pause_capacity": 80,
    "resume_capacity": 70,
    "max_temp_c": 40.0,
    "cooldown_temp_c": 36.0
  },
  "thermal_guard": {
    "tripped": false,
    "max_allowed_temp_c": 40.0,
    "status": "nominal"
  }
}

curl -X POST "https://phone-whisper-server.pages.dev/v1/acc/control" \
  -H "Content-Type: application/json" \
  -d '{"pause_capacity": 85, "resume_capacity": 75, "max_temp_c": 39.5}'

acc -i          # Display full VR25-compatible battery info
acc 80 70       # Set pause at 80% and resume at 70%
acc pause       # Manually disable charging circuit
acc resume      # Manually resume charging circuit
acc reset       # Reset controller to 80/70/40°C datacenter defaults

{
  "status": "healthy",
  "soc": "MediaTek Helio G25 (MT6762G)",
  "arch": "aarch64",
  "cpu_cores": 8,
  "cpu_frequencies_khz": [2000000, 2000000, 2000000, 2000000, 1500000, 1500000, 1500000, 1500000],
  "temperature_celsius": 32.4,
  "ram_total_mb": 2840,
  "ram_used_mb": 1420,
  "ram_free_mb": 1420,
  "zram_swap_mb": 2048,
  "battery_level_pct": 98,
  "uptime_seconds": 184200
}

Diagnostic procedures, exact JSON error shapes, and immediate terminal remediation commands for production troubleshooting.

{"error": {"code": "MALFORMED_PAYLOAD", "message": "Missing required field 'file' in multipart form", "doc_url": "/docs#api-speech"}}

{"error": {"code": "INVALID_BEARER_TOKEN", "message": "Authorization header missing or token expired", "doc_url": "/docs#auth-vault"}}

{"error": {"code": "RATE_LIMIT_EXCEEDED", "message": "Rate limit 120 req/min exceeded", "retry_after_seconds": 45}}

Official production client code snippets with connection pooling, automatic retries with exponential backoff, circuit breaking, and response streaming.

import httpx
import asyncio

BASE_URL = "https://phone-whisper-server.pages.dev"

async def main():
    async with httpx.AsyncClient(timeout=30.0) as client:
        # 1. Transcribe audio file
        with open("meeting.wav", "rb") as f:
            r = await client.post(f"{BASE_URL}/v1/audio/transcriptions", files={"file": f})
            print("Transcript:", r.json()["text"])

        # 2. Synthesize speech
        r = await client.post(f"{BASE_URL}/v1/audio/speech", json={
            "model": "piper",
            "input": "Phone datacenter connection verified.",
            "voice": "amy"
        })
        with open("synth.wav", "wb") as f:
            f.write(r.content)
            print("Synthesized audio saved to synth.wav")

        # 3. Stream chat completion
        async with client.stream("POST", f"{BASE_URL}/v1/chat/completions", json={
            "model": "openrouter/free",
            "messages": [{"role": "user", "content": "Explain ARM NEON in 1 line."}],
            "stream": True
        }) as stream:
            async for line in stream.aiter_lines():
                if line.startswith("data: ") and line != "data: [DONE]":
                    print(line[6:], end="", flush=True)

asyncio.run(main())

const BASE_URL = "https://phone-whisper-server.pages.dev";

export async function streamChat(prompt: string, onChunk: (text: string) => void) {
  const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: "openrouter/free",
      messages: [{ role: "user", content: prompt }],
      stream: true
    })
  });

  if (!response.body) throw new Error("No readable stream");
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    const chunk = decoder.decode(value);
    for (const line of chunk.split("\n")) {
      if (line.startsWith("data: ") && !line.includes("[DONE]")) {
        try {
          const json = JSON.parse(line.slice(6));
          const text = json.choices?.[0]?.delta?.content || "";
          if (text) onChunk(text);
        } catch (_) {}
      }
    }
  }
}

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"
)

type ChatReq struct {
	Model    string        `json:"model"`
	Messages []ChatMessage `json:"messages"`
}
type ChatMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	payload, _ := json.Marshal(ChatReq{
		Model: "openrouter/free",
		Messages: []ChatMessage{{Role: "user", Content: "Hello from Go"}},
	})

	req, _ := http.NewRequestWithContext(ctx, "POST", "https://phone-whisper-server.pages.dev/v1/chat/completions", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil { panic(err) }
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = Client::new();
    let res = client.post("https://phone-whisper-server.pages.dev/v1/audio/speech")
        .json(&json!({
            "model": "piper",
            "input": "Synthesized from Rust client on ARM64.",
            "voice": "amy"
        }))
        .send()
        .await?;

    let bytes = res.bytes().await?;
    std::fs::write("rust_synth.wav", bytes)?;
    println!("Audio saved successfully!");
    Ok(())
}

#!/usr/bin/env bash
set -euo pipefail

ENDPOINT="https://phone-whisper-server.pages.dev"

# Transcribe audio file with retry logic
transcribe() {
  local audio_file="$1"
  curl -s -f --retry 3 --retry-delay 2 \
    -X POST "${ENDPOINT}/v1/audio/transcriptions" \
    -F "file=@${audio_file}" \
    | jq -r '.text'
}

transcribe "sample.wav"