Agent-Native Products. Built on Rust.
We build products and platforms where AI agents are first-class workers—backed by Rust infrastructure that doesn't bend under pressure. Our own products. Our clients' products. All agent-native from day one.
Build With Us Build With UsThe product studio for the agent era
KodeCraft builds AI-native products and platforms—both our own and for clients who see where software is headed. We design systems where agents handle the work and humans set the direction, all on Rust foundations built for the throughput and reliability that agent workloads demand.
See How We Build See How We BuildHow We Build
Map the Agent Surface
We identify which workflows agents should own, which decisions stay with humans, and where Rust infrastructure needs to sit underneath. The result is an architecture where agents and people each do what they're best at.
Build Agent-First
We ship iteratively with agents integrated from the first sprint—not bolted on later. MCP servers, tool interfaces, orchestration layers, and the Rust services underneath all evolve together through continuous delivery.
Deploy & Orchestrate
Production means agents running real workloads under monitoring, with guardrails, observability, and the kind of infrastructure reliability that Rust and our HashiCorp stack make possible at scale.
Agents do the work. Rust holds the line.
Our stack is purpose-built for agent workloads—high-throughput Rust services, MCP-based tool interfaces, and infrastructure that stays predictable when agents are making thousands of decisions per minute.
See the Stack See the Stack
Agents First, Infrastructure Always
We don't treat agents as a feature. They're the architecture. Every system we build assumes agents are doing the heavy lifting—and that the Rust infrastructure underneath them has to be rock-solid.
We Build What We Believe In
We're a product studio, not a body shop. We build our own agent-native products and we build for clients who share the conviction that agents are how serious software gets built from here on out.
Rust Is the Foundation
Agent workloads are unpredictable, bursty, and unforgiving. Rust gives us memory safety without garbage collection pauses, fearless concurrency, and the performance ceiling that agent-driven systems need to scale without surprises.
Our Stack
Purpose-built for agent workloads. Chosen for performance, safety, and predictability.
Backend
Rust, Axum, wasmCloud, Tower
Frontend
TypeScript, SolidJS, React, Leptos
Data
PostgreSQL, TigerBeetle, TigerData (Time-series), pgvector
Infrastructure
Terraform, Nomad, Vault, Consul, Boundary, GitLab CI/CD, Docker, Proxmox
Agent Tooling
MCP Servers, Claude, OpenAI, Agent Orchestration, Tool-Use Pipelines
Quality & Observability
Playwright, Agent Trace Logging, Guardrail Validation
Our Team
The engineers and builders behind KodeCraft. Humans and agents, working together.
Louigie T. Aductante
Gabriel A. Biler
Von Maverick Billones
Mark Louis Delos Santos
Maria Victoria C. Depusoy
Marycris P. Encomienda
Herald Jhan C. Matienzo
Mark Anthony V. Ortal
John Carlo P. Rabe
Jauries Davies A. Rasay
Esmer Josef O. Santiago
Jed Benedict F. Loba
Syron Arapeles
Franz Delos Santos
Gabriel G. Santoc
Ralph Jahred D. Magpantay
John Rafael P. Masilungan
David Jaynes Rogado
Engagement Models
Whether you need a focused build or an ongoing product partnership, we bring the same agent-first approach. Transparent pricing, no surprises.
Focused Build
Project /based
- Fixed scope & timeline
- Agent-native MVP or prototype
- MCP integration & tool design
- Dedicated engineering lead
- Post-launch support
Product Partnership
Ongoing /monthly
- Dedicated agent-native team
- Continuous delivery & iteration
- Agent architecture & code reviews
- Priority support & SLA
- Scaling, orchestration & optimization
Frequently Asked Questions FAQs
Straight answers to common questions about how we work.
From the Blog
Technical writing on agents, Rust, and building what comes next.
Infrastructure for Agent Workloads: Our HashiCorp Stack
Agent-driven systems demand infrastructure that handles unpredictable traffic, dynamic scaling, and zero-trust security. Here's how our HashiCorp stack delivers.
MCP and the Architecture of Agent-Native Products
The Model Context Protocol is becoming the standard interface between agents and tools. Here's how we design MCP-first systems and why it changes how products get built.
Why Rust Is the Right Foundation for Agent Infrastructure
Agent workloads are bursty, unpredictable, and unforgiving. Here's why we chose Rust over Python and Node.js for the infrastructure layer that agents depend on.
Get in Touch
Building something agent-native? Have questions about our approach? Reach out—we'd like to hear what you're working on.
Phone
+63 947 997 1263Telephone
(042) 421-8602Office
2F 20-24 Isabang Town Center, Isabang, 4327 City of Tayabas