Ceivo is media infrastructure for the agent era. We take a library of video, make it deeply understandable, and expose it so that AI agents, and the people directing them, can search, reason about, and assemble content at a speed that was not possible a year ago. This piece is written for technical and product leaders evaluating what an agent-native media platform actually looks like in production, and for anyone curious about the tools we reach for to build one.
A word before the tour, because it shapes everything below. Ceivo is open and tool-agnostic by design. Our whole architecture exists to let a team choose the most appropriate model, framework, and cloud service for each job, and to swap any of them out later without a rewrite. So when we spend the rest of this article praising specific tools, read it the way we mean it: this is the stack we reach for most often because it is excellent, not a set of dependencies we have locked ourselves, or you, into.
What Ceivo actually is
It helps to see Ceivo as four layers, each with a clear job.
The analysis tools are what turn raw footage into understanding: models that watch video and produce embeddings, scene boundaries, descriptions, and metadata. Ceivo is built to work with best-in-class analysis models rather than a single hard-wired one, so this layer can evolve as the models do.
The asset knowledge cloud is where that understanding lives. Every scene, transcript, description, tag, and embedding becomes part of a queryable knowledge base for the library, so an asset is not just a file on disk but a richly described, instantly searchable object.
The MCP layer is how agents talk to that knowledge cloud. Ceivo exposes its search, metadata, and asset operations as Model Context Protocol tools, which means any MCP-capable agent can reason about the library and act on it directly, using an open standard rather than bespoke glue code.
The agentic layer is where the work gets done: agents that take an editorial brief and run a real workflow, from discovery through selection to a finished render. This is the layer where model choice, orchestration, and runtime matter most, and it is where the AWS toolset earns its place.
With that map in hand, here is the stack we reach for.
Marengo and Pegasus: the strongest video analysis we offer
Everything downstream depends on the quality of the understanding at the bottom, and for video that understanding is hard. This is where TwelveLabs is in a class of its own, and it is the analysis option we recommend most often.
Marengo is TwelveLabs' video embedding model, and it is built for retrieval. It does not treat a video as a stack of unrelated frames. It reads video the way an editor does, as a continuous multimodal stream where a visual, a spoken line, and a camera move only mean something in relation to each other and to time. That is the difference between a system that can tell you a frame contains a person and one that can find the exact moment a character first walks into the room. Run through Ceivo, Marengo turns hours of footage into timecoded scenes and semantic embeddings, so a natural-language query like "the wide establishing shot before the interview" lands on the right moment instantly. TwelveLabs recently pushed this further with Marengo 3.0, and every gain in the model shows up directly as sharper search and cleaner scene boundaries for our users.
Pegasus is the other half of the pair, and it is the piece we lean on whenever a workflow needs language about the footage rather than coordinates within it. Pegasus is TwelveLabs' video language model: point it at a clip and it watches the whole thing, then writes back something a human would actually recognize, a plain-language summary, a shot description, a set of highlights, or structured metadata we can index and search against later. That matters enormously in media, where an asset is only as findable as the words attached to it. Pegasus generates those words at scale, so a library that arrives as raw footage leaves as a described, queryable archive without a single person tagging clips by hand.
Marengo tells us where things are; Pegasus tells us what they are. One for retrieval, one for description, both feeding the knowledge cloud. Together they are the reason a Ceivo library is worth pointing an agent at in the first place, and they are why TwelveLabs is our first recommendation for anyone serious about video understanding.
Bedrock and AgentCore: an integrated toolset for the agentic layer
Once the library understands itself, the challenge becomes orchestration: hosting an agent, giving it memory, connecting it to the world, keeping it secure, and letting it reason with the best available model. Amazon Bedrock AgentCore is the toolset we most often use to build that agentic layer, because it provides those pieces as managed services that fit together cleanly.
AgentCore, element by element
Runtime is a serverless home for agents that does not care which framework you brought. We run our orchestration logic, speak MCP as our tool protocol, and let AWS handle session isolation and scaling. That matters because media work is not chat: a promo build or a compliance pass can run over a lunch break, touching thousands of assets, and Runtime gives each of those long sessions a clean, isolated place to execute.
Memory gives agents a real place to remember. A rich scene-level search result is too big to keep in a model's head, and a workflow that spans hours cannot live inside a single context window. Memory holds what matters across a session, including which clips were rejected and, critically, the editorial reason why, so a producer can return later and say "swap the third clip for something with more motion" and get an intelligent answer.
Gateway connects agents to real systems, AWS services and popular third-party apps alike, without hand-writing a fragile integration for each one. An agent that can notify a team or check an approval state is far more useful than one that can only talk to itself.
Identity answers the question every enterprise media buyer asks first: who is this agent allowed to act as, and how do you know? It validates access for the users and applications calling agents and tools, and plugs into the identity providers an organization already runs. For a platform built on trustworthy media governance, handling this at the runtime layer is what lets a security team say yes.
Code is the built-in Code Interpreter, a secure sandbox where the agent can write and run code when a task needs a precise answer, computing exact in and out points or checking that a set of segments sums to a target duration. The agent reasons, but when it needs real arithmetic it runs code and gets it, instead of guessing.
Browser is a fast, secure, cloud-based browser the agent can drive when a task genuinely lives on the web. We reach for it sparingly, but when a workflow needs something that only exists in a web UI, a managed browser runtime one tool call away beats bolting on a scraping stack.
Observability is the feature we would fight to keep. It provides built-in metrics across Runtime, Memory, Gateway, the built-in tools, and Identity, landing in Amazon CloudWatch where operators already work. When an agent makes a decision, we can see the calls it made; when a workflow goes sideways, we read a trace instead of guessing. Debugging an agent becomes ordinary operations.
Bedrock and Mantle: choosing the right model for the job
The analysis layer benefits from stability, but reasoning is a place you want to keep improving, and this is where the openness we opened with becomes concrete.
Bedrock foundation models give us a single, unified surface over a large and fast-growing catalog: the Anthropic Claude family, Amazon Nova 2 with configurable extended thinking, hybrid-reasoning open-weight models like DeepSeek and Alibaba's Qwen3, and, as of June, Grok 4.3 from xAI, a reasoning-first model with configurable reasoning effort and strong tool use that suits agentic workloads especially well. New providers arrive through the Bedrock Marketplace almost monthly.
Mantle is the newer piece, and it is the one that makes all that choice practical. Mantle is a new inference engine in Amazon Bedrock, built for price-performance with native support for tool calling, structured output, and response streaming. In effect it is an abstraction layer for models: it lets us treat a reasoning model as something you plug in rather than something you build around.
How Ceivo uses this is the payoff. Because AgentCore Runtime is model-agnostic and Bedrock plus Mantle make models interchangeable, choosing the reasoning brain of an agent is a configuration decision, not an engineering project. A team can run one agent on a frontier Claude model for a demanding assembly and another on a leaner, cheaper model for high-volume lookups, and can promote a stronger model the week it lands without touching the capability layer underneath. The skill stays the same; the model just runs it better. That is what tool-agnostic means in practice: you pick the right model per agent, and you are never married to yesterday's choice.
Choosing well takes evidence, which is why Ceivo puts a cost-versus-performance view directly in the administrator's hands. For any agent, an operator can benchmark the same workload across the Bedrock catalog and see what each model actually costs, how many findings it returns, and how the two trade off, so the choice between thoroughness and cost stops being a guess and becomes a number an operator can own, agent by agent.
Averages tell you which models to shortlist; they do not tell you whether a model is actually right. For that, an operator can open the same benchmark run in the findings explorer and see the work itself: one scene, one rule, and every model's answer side by side, with the severity each one assigned, what it cost, how long it took, and the exact prompt it was sent and the response it gave back. Agreement across models is a finding you can trust; a lone flag is one worth a second look. When a new model is released, it runs against the same benchmark as everything else, and within a single pass an operator can see whether it earns further investigation, all without changing a line of the agent underneath it.
Conclusion
Step back and the picture is clean. Ceivo turns a video library into a searchable knowledge cloud, exposes it over an open MCP layer, and lets agents do real editorial work on top. For the analysis layer we most often recommend TwelveLabs Marengo and Pegasus, the strongest video understanding models we have worked with. For the agentic layer we most often build on Amazon Bedrock AgentCore, with Bedrock foundation models and Mantle giving every agent its choice of reasoning model. None of these layers is welded to the others, which is the whole point: the stack is excellent, and it is also replaceable, because open infrastructure is the only kind worth building on.
Get in touch
Ceivo and TwelveLabs offer a joint solution for teams that want best-in-class video understanding wired straight into an agent-native media platform. Reach out and we will set up a working session against your own footage.