I operate across the full stack — from Rust async runtimes and edge inference pipelines to React/Next.js products and agentic AI orchestration layers. My default mode is 0-to-1: take an undefined problem and make it real, fast, and observable.

Current technical focus:

• Agentic AI & LLM orchestration — typed tool-calling, policy enforcement, bounded execution, structured trace history
• Edge AI & computer vision — camera-to-event pipelines for constrained hardware (Raspberry Pi, Kneron KL520)
• Low-latency systems — Rust gateways with cache layers, telemetry counters, and sub-10ms targets
• FastAPI / Python backend — production-grade async APIs with Pydantic contracts and observability
• Operational tooling — everything a high-growth startup needs to move fast without breaking things

Typed, policy-controlled, observable execution for tool-using agents.

A production-style agent runtime built to prove what "safe agent execution" actually means in code — not in theory.

• Tool allowlisting — agents can only call pre-approved tools
• Policy validation — every run checked against a configurable policy before execution
• Dry-run mode — validate the plan without executing it
• Structured event history — full trace of every state transition
• FastAPI layer — POST /runs, GET /health, ready to deploy
• Tests pass without an API key — deterministic local behavior

# What a typed agent contract looks like
class AgentRun(BaseModel):
    run_id: str
    policy: Policy
    tool_calls: list[ToolCall]
    state: ExecutionState
    history: list[Event]

Inference pipeline designed for constrained edge hardware.

Built against real constraints: 512 MB RAM, 1-core ARM, no GPU, intermittent connectivity.

• Versioned event schema — every detection event is typed and timestamped
• Bounded queues — explicit drop_newest / drop_oldest policy, no silent data loss
• Fake inference adapter — swap in real YOLO/ONNX model without touching the relay
• Async relay — non-blocking ingest loop
• FastAPI ingest endpoint — receive events from any upstream
• Hardware budget documented — CPU %, RAM, queue depth all specified

Axum + Tokio gateway with cache, telemetry, and mock upstream.

Built to demonstrate systems thinking in Rust: cache-aside pattern, atomic telemetry counters, integration test suite.

• Sub-10ms p99 target — documented benchmark methodology
• Cache-aside layer — HashMap-backed with TTL eviction strategy
• Telemetry counters — requests, cache hits, cache misses, upstream errors
• Mock upstream adapter — integration tests that don't need a real service
• Axum routing — typed extractors, structured error responses

Public case studies for systems where the source is private.

Three production-class case studies with decision records, architecture diagrams, and trade-off analysis:

1. Agentic ERP Middleware — control-plane/data-plane separation, provider adapter pattern, benchmark methodology
2. Edge Vision Deployment — device budget, offline relay strategy, hardware trade-offs, rollout plan
3. Browser Agent Safety — Observe → Plan → Validate → Approve → Execute state machine, threat model, prompt injection boundary

Validate before you run.       // Dry-run mode, policy checks, schema contracts
Bound your queues.             // No unbounded growth; explicit drop policies
Measure before you claim.      // Benchmarks with methodology, not marketing numbers
Name your failure modes.       // Threat models, offline strategies, drop behaviors
Separate control from data.    // Clean boundaries between orchestration and execution

• 📧 jonathanjaladi7@gmail.com
• 🌐 Systems Casebook — architecture portfolio
• 💼 Open to founding-engineer and senior engineering roles at high-growth startups