
Weekend Showcase Challenge: Timothy, a Personal AI Productivity Agent
Timothy is a self-hosted personal AI productivity agent powered by Amazon Bedrock and several other LLM providers. It is designed to help with real tasks instead of only generating text. It can research topics using web search and web fetching, run long-running code sessions, keep long-term memory, run tools in a controlled workspace, and track the cost of model usage.
The problem and solution

A normal AI chat can answer questions, but real work often needs research, coding, tools, memory, and automation. Timothy brings these capabilities together in one agent.
Timothy is a self-hosted personal AI productivity agent powered by Amazon Bedrock and several other LLM providers. The goal is to make AI useful for real work, not just conversation.
For research, Timothy can search the web, fetch pages, and return answers with real sources and citations. For coding tasks, it can follow coding workflows and use tools in a controlled workspace. It can also remember useful facts and decisions across sessions, use tools such as a calculator and shell, and track the cost of every model call.
The agent is built around a controlled agent loop. The model decides what it needs to do, while the application handles tools, memory, permissions, and state. Dangerous actions require user confirmation. This keeps the agent useful while making tool use safer and easier to understand.
For the showcase, I focused the demo on the research workflow, but the underlying system supports coding tasks, memory, tools, and other productivity workflows.
Process, key decisions, challenges

Timothy is a monorepo with three Go services called brain, gateway, and memoryd, plus a React frontend. I started building it as my personal AI setup and used this challenge to refine the core experience and strengthen the AWS integration.
The gateway is the only service that communicates with language models. I added a native Amazon Bedrock driver using the AWS SDK for Go and the Converse API. It handles streaming, tool calling, and usage tracking.
Sessions are event-sourced. Every user message, assistant response, tool call, and compaction is stored as an immutable event in PostgreSQL. This makes conversations durable and allows me to replay exactly what happened.
Timothy has a dedicated memory service using PostgreSQL and pgvector. It combines vector search, keyword search, and recency so that memory is more useful over time.
Tools such as web search, web fetch, shell, calculator, memory, and time all go through the agent loop. Permission checks and constraints are applied before tool execution. Skills are loaded only when needed so the main prompt stays small.
One important challenge appeared when Bedrock handled parallel tool calls. A follow-up request caused a validation error because tool results were packaged incorrectly. Since the conversation was event-sourced, I could replay the exact failure, turn it into a test, fix the message merging logic, and verify the result against real Bedrock.
AWS services used and a brief architecture overview

Amazon Bedrock is the core AWS service. Timothy uses Bedrock with Amazon Nova models for chat, reasoning, streaming, and tool calling through the Converse API. Nova Lite and Nova Pro can be selected based on the task.
Amazon ECS Fargate runs the containerized Go services and React frontend. Amazon RDS hosts PostgreSQL, including pgvector for long-term memory.
The high-level architecture is:
Browser
→ React frontend
→ Brain service on ECS
→ Gateway service on ECS
→ Amazon Bedrock
The brain service manages the agent loop, tools, skills, permissions, and event-sourced sessions. The memory service connects to PostgreSQL and pgvector on RDS. Amazon Titan Text Embeddings v2 is used to generate vector embeddings for memory search. The gateway records model usage and cost information for the usage dashboard.
I also use a private SearXNG instance for web search so that search queries remain under my control. AWS Secrets Manager is used as a secrets backend for storing the LLM provider and connectors credentials.
What I learned across the summer

The biggest lesson was that a useful AI agent needs more than a strong model.
Event sourcing made the system much easier to debug because I can replay the exact history of a conversation. The permission system and tool constraints are also essential when an agent can use shell commands or other powerful tools.
I also learned that practical memory needs more than vector search. Combining vector search, keywords, and recency worked better for a personal assistant.
Cost tracking changed how I think about model selection. When the cost of every model call is visible, it becomes easier to choose the right model for each task instead of always using the most powerful one.
Finally, separating deterministic application logic from model intelligence made Timothy more reliable. The model handles the intelligent part of each task, while the application controls state, memory, tools, permissions, and execution.
Link
Builder who inspired me
@mitulshahriyar - always inspires me.
Try out Timothy. Feel free to provide suggestions and feedback.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article