In my past career, I worked in academic research and led a small group across international institutions, without any dedicated orchestration tool for notes, data, sample management or instrumentation. The result was predictable: individual (non-digital) lab notebooks, scattered digital documents, data in several places, with my own memory expected to hold it all together for perpetuity. When someone asks me about some of that work today, reconstructing the details, particularly for work that was not summarized in a publication, is painful, and a lost opportunity for others to learn and build on what we've done.

Research tools like RSpace, especially with AI on top of it, could have changed that. If my documentation would have been more structured, organised, and orchestrated, anyone (me, a collaborator, a researcher who wants to build on top of my work 10 years later) could go back and reconstruct exactly what was done with ease.

That ability to retrace, even or particularly when an AI is doing some of the work, is what this post is about.

From talking about your data to talking to it

For a while, AI in research meant something close to chatting with yourself. You asked a chatbot questions, got answers, copy-pasted, edited. That kept you intentional at every step and was genuinely useful, but it sat next to your work rather than inside it. It was a cumbersome way to work.

Agents changed that. They do not just read what you share into a chat window; they can be empowered to do things autonomously, find context from your documentation, use or create on-the-fly tools to pull a dataset, run an analysis, and integrate results into your documentation. That raises two questions that matter everywhere but even more so in science. Can you trust what the agent did? And can you go back later and tell what was done by a human and what by an agent, step by step?

These are not the same question. Trust is about the single action (or train of actions an agent takes). Auditability and provenance are about everything before and after it: the process. Research needs both, but it cannot survive without the second. A result you cannot retrace is a result you cannot defend.

See also our discussion at the latest Barcamp Open Science in Berlin.

Treat your AI like a team member

This is where RSpace already, and potentially other research tools with auditable and permissioned content management, can do something concrete rather than aspirational.

Access to RSpace outside the web interface runs through an open API, accessed through user-generated API keys. Just like in the web interface, every API interaction runs through the same audit and versioning engine, and the API key identifies which user is acting. So a straightforward way to keep AI actions distinguishable is to give the agent its own user account. You treat that account like a lab member: you add it to your lab and project groups, share content with it exactly as you would with a colleague or a project team, and thereby also restrict it to what you want it to see. Every action your AI team member takes on RSpace-managed data lands in the audit trail, and documents and data touched by it are versioned automatically. Even more so, the same notifications about content updates go out to your colleagues as for any other team member.

The agent therefore works inside the same auditable, permissioned environment as everyone else, so "the AI did something" becomes "here is exactly what happened, under which account, and I can show you." Provenance stops being a promise and becomes a record.

What that lets you do

A team member like this can be genuinely useful, and it can even be a shared resource for a group. It can summarise a project and draft a report, flag gaps in your records, tidy up your inventory, pull in an external data source, and nudge your documentation toward FAIR standards, all on data it is allowed to touch and all written to the same audit trail as everyone else's work. And because useful patterns can be captured as templates in RSpace or shared as instructions for the agent using skills or reference documents in RSpace, the good ones become repeatable rather than less stable, one-off prompts. Moreover, you can instruct an agent to automatically keep a memory of its actions using RSpace documents.

One door in, many ways through

So how do you actually connect an AI agent to RSpace? There are several routes to the same functionality: the RSpace MCP server, CLI tools, the Python SDK, or the API directly. For most LLM-based tools, both commercial and on-premise hosted solutions, the MCP server is the natural default, and not only because it is convenient. It sits as a layer between the AI tool and RSpace, so you can give it workflow-specific context and guardrails, and it keeps your credentials on your own machine, out of reach of the AI tool and its provider. Going through the SDK or the API directly gives you more control, but then handling those secrets safely is on you.

Build your own tools, in a trusted environment

So far this has been about pointing existing AI tools at RSpace, but you do not have to stop there. Conversational agents are a blunt instrument for some jobs, and they burn a lot of resources: repeatable or rule-bound tasks are often better handled by a small, deterministic tool that you then hand to the agent. And because AI has collapsed the cost of building such tools, the question that used to be "can I get someone to build this?" is now "what if I built it myself?"

That is empowering, but also daunting: does building it yourself mean stepping outside the safe, governed setup? It does not have to. You build the tool on the RSpace API or an intentionally designed SDK like the Python SDK, and run it against its own RSpace account, so it operates inside the same trusted, audited environment as everything else, and everything it does stays permissioned, versioned, and on the record.

Agentic workflows across tools: RSpace and Dataverse

The same accountable-agent idea does not have to stop at RSpace's boundary. RSpace already offers a wide range of integrations with other tools and services, and you can let an agent orchestrate workflows that span several of them. The example Slava Tykhonov (CODATA) and I presented at the Dataverse Community Meeting bridges two worlds that are usually disconnected or one-directional: the active, evolving, highly contextual data that lives in RSpace, and the curated, archived, FAIR datasets that live in repositories like Dataverse.

To reuse data, crossing that gap is normally manual and multi-step: search the repository, read the documentation, download files, wrangle the data, import it, and combine it with your own. That friction is a big part of why data reuse is still not common in science, and a real lost opportunity. Both RSpace and Dataverse expose MCP servers, so you can point one AI tool at both. Ideally, the data is described in a way an agent can unambiguously interpret and act on. That is what Croissant (an MLCommons semantic standard for datasets) and the Cross-Domain Interoperability Framework (CDIF) provide: a shared, machine-readable description of variables, a lingua franca the agent can reason over without custom parsing for every dataset.

So in practice consider the following: you have freshly collected data documented in RSpace, and you ask your assistant to find published datasets describing variables with the same meaning across Dataverse instances, compare your preliminary findings against those baselines, and pull the relevant data back into RSpace. From there you can route the integrated result to a Galaxy workflow for instance, and the new dataset you obtained from there can be published back to a repository for others to build on. Active and archived data stop being two separate worlds, and you get a small research and innovation flywheel: new data leads to new research, which leads to new data.

Slava Tykhonov (CODATA) and I walked through this in detail at DCM 2026 in Barcelona.

So how much in control are you still?

It is worth being precise about what "control" means here, because it means different things to different people. RSpace has mechanisms to sign and lock documents and to manage view and edit rights, but its focus is collaboration on a shared knowledgebase. So, just as with people working together in RSpace, it does not force a human to approve every action before an agent takes it; that would strip the agent of agency and slow the work down, exactly as it would one of your colleagues.

Control comes from a different place. Every action is traced, documents and data are versioned so you can restore an earlier state, and a document can be locked once it is final. FAIR standards and controlled vocabularies add further guardrails, and proposals like Slava Tykhonov's semantic Croissant go furthest: they embed machine-readable usage policies (through ODRL) and trust signals (through decentralised identifiers) into the data itself, so an agent can check what it is allowed to do before it acts, rather than leaving us to catch problems afterwards.

Oversight is therefore continuous and recoverable rather than a gate the work has to queue behind. You stay in control through visibility and the ability to undo.

Where this goes

It is hard to make firm predictions on how research practice might change at the current pace of AI development, but the shift toward interacting with machines conversationally, and with increasing utility and agency, is likely here to stay and grow. There is also growing consciousness about the risks and sustainability challenges of hyperscaler solutions, but routes to more sovereign, standards-based AI are already being explored, semantic Croissant among them, and I am confident that organisations and individuals will find their way.

What is already certain is that the importance of provenance and trust in digital objects are magnified to an unseen degree, and that demands reliable frameworks rather than good intentions. For that future to be trustworthy and not merely fast, something has to hold the record together and provide effective guardrails. This has to hold across the whole research stack, not just one tool. RSpace is one contributor to that layer, alongside the other tools and repositories an agent touches.

Try it

• Try the RSpace MCP server. The fastest way to get an assistant working through RSpace yourself: github.com/rspace-os/rspace-mcp
• Share your experiences with us. We have regular community calls where you can share your learnings or new tools you built around RSpace with us and other RSpace users: github.com/rspace-os/community