AI
Applied AI and agent engineering — we build the bidirectional-MCP agent frameworks, owned BSP execution engines, and guardrails others consume, delivered client-owned.
Agentic Automation
We build agents that do work against your files, systems, and shell — autonomously, but governed. The agent runs unattended, yet every consequential tool call is screened before and after it runs, and risky operations pause for a human "yes." Safe autonomy on a runtime you own — agents that act, not chatbots that talk.
AI Strategy & Prototyping
We de-risk your AI bet with rigorous, evidence-first prototyping and the engineering disciplines that make AI behaviour knowable — guardrail and eval engineering, and a capability-gated test harness that runs against real providers, not mocks. The buyer's first question is "how do you know it works?" — we answer with code, not a deck.
AI-Enabled Internal Tools
We build your team's own internal AI assistant on your stack — an agentic tool that reads, writes, and runs commands through your tools, or a conversational interface over your knowledge base — with your tools wired in and a human in the loop where it matters. Your tools, your stack, your governance, your code.
LLM / GenAI Integration
We wire LLMs into your product without welding you to one vendor — a single typed API that talks to Anthropic, OpenAI, and Google Gemini interchangeably, with streaming, tool calling, and cache-aware per-component cost. The vendor seam is the product, swapping a provider is configuration, and you own it.
Custom MCP Server Development
We build standards-compliant Model Context Protocol servers — and the clients that connect to them — proven against the official reference SDK, that expose your systems to any AI assistant as governed, typed tools. Both ends of the protocol, built by one team, and you own the code.
Multi-Agent Workflow Engineering
We engineer your business process as a multi-agent workflow — parallel fan-out and fan-in, conditional routing, nested sub-workflows, and human-approval gates — on a deterministic orchestration engine we built and own. You are not paying for "we call an LLM in a loop"; you get a runtime with real join semantics, and you own it.
RAG & Knowledge Systems
We build retrieval-augmented generation as an operated subsystem — drop your content in, get back grounded, citation-anchored answers. An ingestion worker embeds your content, a hybrid vector-plus-keyword retriever fuses and authorizes results, and an LLM synthesizes cited answers — with a daily reconcile keeping the index honest. Built and operated in production.
- A tool-execution loop over a built toolset — read, write, edit, search, run a command, fetch the web, delegate a subtask — with file tools that write to a branch-versioned store; the file-tool integration tests run green against the real data layer.
- A guardrails pipeline fused to a human-approval gate, wired straight into the tool-execution loop — input screen, then approval, then output screen — with a three-state pass / block / escalate verdict; the guard suite and the block-path integration test run green.
- A side-effecting tool blocks on a human 'yes' before it runs and fails closed on denial — proven by green integration cases, with node-failure escalation running end to end through the real engine.
- A graph-native context-compaction engine — non-destructive per-turn folding plus a history-summarization safety net — wired into the agent runtime, with a live visualizer that prints per-turn compression.
- A capability-gated test harness — a per-provider capability matrix, attribute-driven gating, and real-provider integration against the live Anthropic, OpenAI, and Google SDKs, asserting on real token and usage metrics; the suites run green.
- A native guardrails framework with a pluggable extension point and a three-state pass / block / escalate model — the substance behind 'we engineer safety into your agents, not bolt on a vendor filter.'
- Runnable prototypes that stand up fast — an agentic-coding demo with a multi-provider CLI, and an orchestration fan-out demo — to de-risk an agentic build live.
- A built toolset — read, write, edit, search, run a command, fetch the web, delegate, plan, invoke a skill — over a typed tool registry with schema-validated arguments; the extension seam a buyer plugs their own tools into, with an interactive multi-provider CLI host.
- MCP tools surfaced live into an LLM tool loop via a console bridge — internal capabilities exposed as MCP tools, then one-command-installed into developers' Claude Code and Cursor.
- A production-grade in-site conversational AI chat surface — streaming answers, inline citations, file attachments, per-user thread management, reconnect with de-duplication — built and operated, with end-to-end browser tests.
- A provider-agnostic client seam delegating to any provider implementation — three live cloud adapters for Anthropic, OpenAI, and Google, each with real-API integration tests, plus a deterministic fake for offline testing.
- Cache-aware cost accounting — the usage model stores standard, cache-read, and cache-creation input components first-class, each priced by its own rate; cost accounting runs end to end against the real Anthropic API.
- A complete typed streaming event taxonomy and a typed tool-calling model, with the real Anthropic adapter yielding the events and converting tool definitions to the SDK's own shape.
- A complete MCP server runtime — dual stdio and Streamable-HTTP transports, the full method surface, attribute-based tool/resource/prompt discovery, and JSON-Schema synthesis — pinned to the current spec revision.
- Wire-format conformance proven against the official Microsoft MCP SDK — our server spawned as a subprocess and exercised by the reference client, end to end.
- A from-scratch, full-protocol MCP client with a six-state connection machine and a multi-server registry — verified against the reference SDK server across dozens of integration cases.
- An owned bulk-synchronous-parallel orchestration engine — deterministic supersteps, And/Any join semantics, data-driven branch-pruning, recursive sub-workflow nesting, and inline human-in-the-loop escalation — backed by hundreds of automated tests across dozens of files.
- A type-safe, declarative agent-graph builder with three-color cycle detection, sub-workflow nesting, And/Or/race joins, and least-privilege tool governance per node — validated at build time, fully unit-tested.
- A runnable demo — a splitter fans out to parallel workers and an aggregator joins them across multiple supersteps — printing each round as it advances, against a real LLM provider.
- A queue-driven ingestion worker — embed, persist, idempotent vector upsert — and a hybrid retriever running vector and full-text branches in parallel, fused by reciprocal-rank fusion, with an always-on post-filter re-checking every candidate against permissions; densely test-backed including a real vector-database integration tier.
- LLM-grounded synthesis with numbered citation markers (out-of-range markers silently dropped) plus a daily drift-reconcile that self-heals the index; production fixes confirm it shipped and ran.
- A retrieval-over-MCP tool surface — the retriever exposed as MCP tools under the calling user's identity — bridging this capability to the native MCP wedge.