Agent.Press

Every production assistant needs the same substrate before it can do anything client-specific: somewhere to keep conversation state, a way to give the model tools and validate what comes back, retrieval over documents the client owns, and a console someone non-technical can configure and watch it from.

Built per engagement, that substrate is where reliability goes to die. Four clients means four subtly different retry behaviours, four tool contracts, four ways of handling a model that returns something unexpected, and four codebases to fix when one of them turns out to be wrong.

The platform is a monorepo of applications and libraries with an orchestrated build. What makes it a platform rather than a large project is that the libraries are versioned and released, so a client system takes a dependency on a published version rather than on whatever is currently on the main branch.

A request is not a model call. It is context assembly, a model turn that may ask for tools, tool execution against real systems, validation of what comes back, and a decision about whether to loop again or answer. The runtime owns that loop so no client system has to implement it.

Answers stream to the client over a websocket rather than arriving as one response, because a multi-turn agent that has to call three tools is not something a user should watch a spinner through.

The runtime talks to models through one abstraction with several provider implementations behind it. OpenAI, Anthropic, Google and xAI are all reachable through the same interface, so the choice of model is configuration rather than architecture.

Tools are the boundary between a model and real systems, and therefore the place where an agent platform is either safe or dangerous. Each tool declares its input schema, is executed by the runtime rather than by the model, and returns a structured result that is validated before it re-enters the conversation.

Alongside its own tools, the runtime speaks Model Context Protocol, so an agent can be given capabilities from MCP servers without those capabilities being built into the platform. A client that already exposes its systems over MCP does not need bespoke platform work to make an agent useful against them.

An agent that answers from the model alone is a liability in a business context. Retrieval grounds answers in the client’s own material, held as embeddings in the same PostgreSQL database as the rest of the platform’s state rather than in a separate vector service.

Material arrives as uploaded documents, as text entered directly, as structured tables, and as web pages that have to be fetched and extracted. Each path ends in the same place: chunked, embedded and searchable. Documents land in object storage; the extracted content is what gets embedded.

The API is the platform, but almost nobody uses an API directly. The console is where an agent is configured, its knowledge managed and its conversations inspected. The drop-in chat client is a small embeddable build that puts an agent into an existing product without that product taking on the platform.

The console is a single-page application with typed routing, server-state caching and schema-validated forms. Long conversation and knowledge lists are virtualised, because an agent that has been running for months has more history than a browser will render.

A platform carrying several clients’ systems has to be defensible before it is clever. Sessions and OAuth are handled by a dedicated auth layer against the same database, and the API carries the ordinary protections a public surface needs.

A deterministic service can be debugged from logs and a stack trace. An agent cannot: the same question can take a different path through tools and turns on two consecutive days, and "it gave a bad answer" is not a stack trace.

The runtime is instrumented with OpenTelemetry, exporting traces and logs over OTLP, so a single conversation can be followed across its turns, its tool calls and its retrieval — which is the only way to answer why a particular answer came out the way it did.