Trajecta.

A thin desktop application talks to a FastAPI backend. The backend prepares a stateful agent and mediates model calls, tool permissions, retrieval, and learning. The important boundaries remain visible in the diagram.

The process is designed to stream progress to the UI while retaining enough state to resume after a user decision or regenerate from an earlier turn.

1. 01

   Validate the request

   FastAPI receives the conversation or scheduled task. Input checks and preflight validation run before SSE headers are emitted; conversation and workspace settings are resolved.

   server/src/chat/service.py
2. 02

   Select a model and tools

   The runtime resolves the selected model through Bifrost, loads enabled local and MCP tools, takes a permission snapshot, and binds all workspace-sensitive tools to one validated folder.

   server/src/chat/runtime.py
3. 03

   Retrieve relevant context

   Bounded hybrid retrieval draws from semantic facts, scoped episodes, approved experiences, and active version-matched skills. Retrieval failure is advisory rather than fatal to a chat turn.

   server/src/memory/retrieval.py
4. 04

   Execute a stateful agent

   Deep Agents and LangGraph handle planning, tools, checkpoints, and branching. Streaming events distinguish output, tool activity, errors, and interruptions.

   server/src/chat/runtime.py
5. 05

   Ask before sensitive actions

   The policy can hide denied tools or interrupt calls requiring approval. Pending decisions survive through a checkpoint and resume after the user decides.

   server/src/guardrails/policy.py
6. 06

   Persist the evidence

   The conversation, checkpoint, final outcome, and agent trajectory are recorded. Meaningful tool-using runs can produce scoped episodes and optional reflection jobs.

   server/src/chat/service.py

Trajecta separates ephemeral execution state from durable facts, evidence-linked episodes and executable procedures. Raw trajectories are stored independently so useful history can be inspected without treating every event as reliable memory.

The learning design is intentionally not a self-modifying loop that silently rewrites the agent. It distinguishes observed events, suggested lessons, reviewed knowledge and evaluated executable skills.

What the evaluation pathway measures

These are evaluation dimensions and checks provided by the project—not published claims of a measured improvement or automatic skill-promotion rate.

Permissions are stored and enforced by the application. Input and model-context checks handle untrusted content, while LangGraph provides resumable human-in-the-loop decisions for tool calls and questions. Docker-based isolation is an optional execution mode, not a blanket guarantee for every connected service.

These short, annotated excerpts come from the project source. The GitHub repository is not currently publicly accessible, so source paths are presented as references rather than broken external links. They show three design decisions: bind tools to a workspace, fail softly on retrieval errors, and keep review decisions explicit.

workspace_root = conversation_workspace(conversation, self._settings)
personal_tools = self._personal_tools.for_workspace(workspace_root)

native_tools = personal_tools.filter_tools(
    personal_tools.get_tools(),
    policy,
)

except Exception:
    # Memory search is advisory; it must never break a chat turn.
    logger.warning("Unified memory retrieval unavailable", exc_info=True)

if decision not in {"approve", "reject"}:
    raise ValueError("decision must be approve or reject")

new_status = "active" if decision == "approve" else "rejected"

Explore the modules

Trajecta is under active development. The useful engineering story includes what the system deliberately does not assume.