Agent Col

the collaborative partner track for the all things agentic hackathon contest

Comment

Inspiration

My inspiration for Agent Col came from a pain point that is visible across nearly every AI model: context rot. AI assistants can be incredibly capable inside a single conversation, but that collaboration often degrades as context grows, sessions end, or important decisions disappear into old chat history. The user repeatedly has to explain who they are, what they are building, what decisions were already made, and how they prefer to work. I wanted to explore a different idea: instead of building another chatbot that simply answers prompts, what if the agent could maintain meaningful continuity with the user over time? Agent Col was built around that question. The goal is a collaborative partner that can remember approved information, preserve project context, carry decisions across conversations, and adapt to the user without silently profiling them or taking control away from them.

What it does

Agent Col is an agentic collaborative workspace designed to maintain continuity between a user, their conversations, projects, notes, memories, and generated artifacts. Users can have normal conversations with Agent Col while the system maintains structured context behind the scenes. Important information can become governed memory, workspace notes can preserve project-specific decisions and requirements, and previous sessions can provide useful continuity without forcing the entire conversation history back into every prompt. Agent Col can also help turn messy ideas into structured outputs, generate project artifacts, receive feedback on those artifacts, and revise them while preserving the surrounding project context. A major design goal is separating different kinds of information by authority. User-approved memory, workspace notes, conversation history, and generated artifacts are treated as different domains rather than being dumped into one giant context window. The result is an agent designed not just to respond to the current message, but to become a more useful collaborative partner as the relationship and project history develop.

How I built it

Agent Col uses a FastAPI backend with Google Gemini through Vertex AI and Google Cloud infrastructure. The system is divided into explicit domains for conversations, workspaces, artifacts, memory, continuity, and collaboration state rather than treating everything as unstructured chat history. Firestore provides durable persistence for conversations, workspace data, memory state, notes, and artifacts. Google authentication is used to establish user identity and enforce ownership boundaries between users and workspaces. The conversational path combines model-driven reasoning with deterministic application logic. Gemini is allowed to interpret natural user intent and generate useful responses, while application-level validation handles things that need stronger guarantees, such as persistence, authorization, schema validation, memory governance, and ownership. For memory, Agent Col does not silently convert model observations into permanent user traits. Potential durable memories move through a governed proposal and approval process before becoming active context. For continuity, the system selectively retrieves useful information from previous interactions rather than blindly replaying complete transcripts. Workspace notes preserve project-specific decisions, requirements, constraints, tasks, and working context independently from global user memory. The browser interface was built as a lightweight workspace around the conversation itself, with separate surfaces for conversation history, project state, memory, notes, and generated artifacts.

Challenges I ran into

One of the hardest problems was deciding where deterministic logic should end and model reasoning should begin. Early versions of Agent Col placed too many rigid contracts directly in the conversational path. The system became technically predictable, but the interaction felt unnatural. It behaved more like a protocol interpreter than a collaborative partner. I learned that deterministic systems are extremely useful for validating actions, permissions, persistence, and data boundaries, but they should not unnecessarily constrain normal conversation. Memory created another difficult problem. Allowing an AI system to infer and permanently store arbitrary information about a user would make continuity easy, but it would also create serious trust and governance problems. I instead built a system where the model can identify potentially useful information, while deterministic policy and explicit user approval control whether it becomes durable memory. Cross-session continuity was another significant challenge. Simply injecting old conversations into the prompt does not scale and eventually recreates the same context-window problem I was trying to solve. I had to separate chat history, workspace knowledge, collaborative notes, and durable memory so that each could be retrieved and used intentionally. I also encountered the less glamorous engineering problems that appear when moving from a prototype into a real system: schema mismatches, ownership boundaries, generated metadata exceeding validation limits, model outputs that do not perfectly match application expectations, and maintaining reliable behavior when probabilistic model output meets deterministic software. Those failures ended up influencing the architecture as much as the original design did.

Accomplishments that I'm proud of

The biggest accomplishment is that Agent Col evolved from a conversational prototype into a system with an actual continuity architecture. Agent Col can preserve useful information across separate conversations without treating an entire chat transcript as memory. User memory, workspace notes, conversation history, artifacts, and continuity information have distinct responsibilities and governance rules. I am especially proud of the memory lifecycle. A user can naturally ask Agent Col to remember something, the system can interpret that request, construct a governed memory candidate, allow the user to review it, and only then make it durable. I also built cross-session project continuity so that a new conversation does not necessarily mean starting the collaboration from zero. Another important accomplishment was learning to keep the model flexible while keeping the surrounding system strict where correctness actually matters. Natural language interpretation remains probabilistic, but authorization, persistence, ownership, validation, and user-controlled memory remain deterministic. That separation has become one of the most important architectural ideas behind Agent Col.

What I learned

The biggest lesson was that building a good agent is not just about giving a language model more tools or a larger context window. Long-term collaboration requires information architecture. Different information has different authority, lifetime, scope, and trust requirements. A user's personal preference should not behave like a project requirement. A temporary observation should not automatically become permanent memory. A conversation transcript should not have the same authority as a user-approved decision. I also learned that excessive deterministic control can damage the exact experience it is intended to protect. Validation is necessary, but forcing users to communicate through rigid conversational protocols creates friction. The better pattern is to let the model understand natural language and place deterministic boundaries around the consequences of that understanding. Most importantly, I learned that continuity is not the same thing as remembering everything. Useful continuity comes from remembering the right things, knowing why they matter, knowing where they belong, and giving the user control over what persists.

What's next for Agent Col

I want Agent Col to become increasingly capable of recognizing useful patterns across collaboration while maintaining strong boundaries between temporary observations, project-specific knowledge, and user-approved durable memory. Future work includes better continuity retrieval and ranking, memory deduplication and lifecycle management, stale-memory handling, summarization and compaction, provenance tracking, stronger context-budget management, and richer workspace-level collaboration. I also want to expand Agent Col's ability to perform durable background work, allowing longer-running tasks to continue independently while preserving reliable job state, ownership, and results. Artifact collaboration will continue to grow as well, with richer revision workflows, comparisons between versions, structured feedback, and more types of generated work products. The long-term goal remains simple: Agent Col should not feel like an AI assistant that forgets the user every time a new chat begins. It should feel like your Agent Col — a collaborative partner that learns how to work with you, remembers what matters, and becomes more useful over time.

Built With

Share this project:

Updates