We're building agents that can read millions of documents, but still forget a video they watched yesterday.
▲ 28 r/DeepSeek+7 crossposts

We're building agents that can read millions of documents, but still forget a video they watched yesterday.

One thing has felt odd to me while working with AI agents.

We've gotten pretty good at giving them memory for text.

They can search documentation, index repositories, retrieve past conversations, and even build long-term memory over time.

Videos, though, are still treated as temporary input.

The agent watches a recording, answers a few questions, and when the session ends, that understanding is usually gone. Next session, the same video gets processed all over again.

That feels like an architectural gap rather than a model limitation.

A video isn't fundamentally different from any other source of information. Once you've extracted transcripts, OCR, visual observations, and timestamps, why throw that work away?

I ended up building an open-source project around this idea.

Instead of asking the agent to repeatedly "watch" the same video, it builds a persistent local index the first time. Future questions become retrieval instead of video analysis.

It changed how I think about video in agent workflows.

I'm curious whether others see this as a real missing piece, or if you've already solved it another way.

GitHub: https://github.com/oxbshw/watch-skill

u/Fearless-Role-2707 — 11 hours ago

We're giving agents memory for everything... except video.

One pattern keeps showing up in the agents I've been building.

We spend a lot of time designing memory for text.

Conversation history.

RAG.

Long-term memory.

Knowledge graphs.

Tool outputs.

But videos usually get treated as if they only exist for the current session.

The agent watches a recording once, answers a few questions, and everything it learned disappears. The next session starts from scratch.

That felt like a strange design choice.

A video isn't fundamentally different from a document. It's just another source of information. Once you've extracted transcripts, OCR, visual observations, and timestamps, there's no obvious reason to throw that work away.

I started experimenting with treating video as persistent knowledge instead of temporary input.

The idea is simple:

- Analyze the video once.

- Store structured observations locally.

- Retrieve only the relevant evidence later.

- Let follow-up questions become retrieval instead of video processing.

I ended up turning the idea into an open-source project called Watch Skill, but I'm more interested in the design discussion than the implementation.

If you're building long-running agents, how are you handling video today?

Do you reprocess every recording, or are you persisting that information somewhere?

reddit.com
u/Fearless-Role-2707 — 12 hours ago

Agents can remember conversations. Why can't they remember videos?

I've been thinking about this while building agent workflows.

Most agents have gotten pretty good at reading code, searching docs, calling tools, and maintaining conversational context.

But videos still feel like disposable input.

Every session starts the same way:

- upload the recording

- ask a few questions

- end the chat

- repeat the whole process tomorrow

That feels backwards.

If an agent has already spent time understanding a video, why should it have to watch it again just because the conversation ended?

I ended up building an open-source project around that idea.

Instead of treating videos as temporary attachments, it indexes them once (transcript, OCR, visual information, timestamps) and keeps that knowledge available for future sessions through MCP.

The interesting part wasn't video analysis itself. It was treating videos as something an agent can accumulate knowledge from over time, the same way it accumulates knowledge from documents or code.

I'm curious whether other people building agents see this as a real gap, or if everyone has already settled on a workflow I haven't discovered yet.

github: oxbshw/watch-skill

reddit.com
u/Fearless-Role-2707 — 12 hours ago

Built a web access gateway that I've been using with OpenCode

I've been experimenting with OpenCode for a while, and one thing I kept noticing was that every agent workflow eventually grows a pile of integrations.

GitHub, Reddit, YouTube, docs, search... every project ended up maintaining a different set of APIs and MCP servers.

I got tired of rebuilding that layer, so I started working on a separate gateway that sits between the agent and external services.

I've been using it with my own OpenCode workflows, and it's made switching between providers and tools much simpler because the agent only talks to one interface.

It's open source and still very much a work in progress.

I'm mainly posting because I'd like feedback from people who use OpenCode regularly.

  • Would you rather connect tools directly?
  • Or does having a dedicated web access layer make sense to you?

If anyone wants to take a look:

https://github.com/oxbshw/Agent-Span

I'd really appreciate honest feedback, even if it's "this solves the wrong problem."

u/Fearless-Role-2707 — 7 days ago
▲ 17 r/aiagents+2 crossposts

Does every AI agent project eventually end up rebuilding the same integrations?

I've noticed the same pattern in almost every AI agent project I've worked on.

The agent itself is usually the easy part.

The messy part is everything around it GitHub, Reddit, YouTube, docs, search, APIs, MCP servers, authentication, retries, caching... after a while you're maintaining integrations instead of building the agent.

That got me wondering if agents really need direct access to every service, or if there should be a dedicated "web access layer" sitting in between.

I ended up building that idea for myself and open-sourced it as AgentSpan.

The basic idea is simple: the agent talks to one gateway, and the gateway handles the integrations, routing, caching, retries, health checks, and exposes everything through a consistent API and MCP server.

I'm not claiming this is the right architecture it's just the direction that made the most sense after running into the same problems repeatedly.

I'm curious how other people are solving this.

- Are you calling every API directly?

- Are you relying entirely on MCP servers?

- Do you have your own internal gateway or abstraction layer?

I'd love to hear how everyone else approaches this.

Repo (if anyone wants to look at the implementation):

https://github.com/oxbshw/Agent-Span

u/Fearless-Role-2707 — 7 days ago

I got tired of wiring APIs into AI agents, so I built a gateway instead.

I've been experimenting with AI agents for a while, and one thing kept bothering me.

Every project ended up with a different collection of APIs, MCP servers, browser tools, and random scripts. The agent logic was usually the easy part—the integrations weren't.

So I started building something to simplify that.

It's called AgentSpan.

The idea is simple: instead of wiring your agent to dozens of different services, it talks to one gateway that handles all of that behind the scenes.

Right now it supports 52 platforms, exposes 92 MCP tools, has a REST API, SDKs for 9 languages, adaptive routing, caching, agent memory, and a few other things that made my own workflows much easier.

It's open source and still evolving, so I'm mainly looking for feedback from people building agents.

Would something like this actually be useful in your stack, or am I solving a problem that only I have?

GitHub: oxbshw/Agent-Span

reddit.com
u/Fearless-Role-2707 — 7 days ago

Give your AI agents eyes to the internet. 52 platforms, one gateway, 92 MCP tools, zero integration headaches.

I've been building **AgentSpan**, an open-source web access gateway for AI agents.

While building agent workflows, I kept running into the same problem: every project ended up integrating a growing collection of APIs, MCP servers, SDKs, and scrapers. They all work differently, fail differently, and need to be maintained separately.

I wanted a single layer that hides all of that complexity.

That's why I built AgentSpan.

Instead of talking to dozens of services, your agent talks to one gateway that handles routing, caching, retries, failover, and content processing behind the scenes.

Current features:

* 🌐 52 supported platforms

* 🤖 92 MCP tools

* ⚡ Async Rust core

* 🔌 REST API + SSE

* 📦 SDKs for 9 languages

* 🐳 Docker deployment

* 📊 React dashboard

* 🚀 Adaptive routing \u0026 automatic failover

* 💾 Multi-layer caching

* 🧠 Agent memory

* 📄 Built-in content extraction and token-aware formatting

The goal isn't to replace browser automation or existing MCP servers.

The goal is to give AI agents a single, reliable interface for accessing the web.

I'd really appreciate feedback from people building AI agents.

* Is this something you'd actually use?

* What platforms or features would you want to see next?

* What do you think is still missing?

GitHub:

/oxbshw/Agent-Span

https://preview.redd.it/k813ws85p7ah1.png?width=1440&format=png&auto=webp&s=1f2f0cb5fa76e7875223b32144898f6415fceb2d

reddit.com
u/Fearless-Role-2707 — 7 days ago