meinKontextDocs
Navigation & search

Updates

Roadmap

What comes next for you.

meinKontext is in alpha: only the team and invited testers work with it. In progress is being built now, Planned comes next, the Backlog is recorded but not yet commissioned. What is already there is in the changelog.

We maintain this overview by hand. Once meinKontext's own development runs through meinKontext projects, it will come from the Tasks plugin; the plugin still lacks a few features for that.

In progress

  • Capacity over time for admins. Platform admins get their own area with graphs that show when meinKontext used how many resources: how many copies of each service ran, how busy the processors, memory and database were, and how full the queues got, so that scaling up and down can be followed afterwards instead of being pieced together by hand.

  • More views for admins. Besides the capacity graphs, platform admins get a view of which version each part of meinKontext is running and whether maintenance is switched on, a list of background jobs that failed for good with the option to retry or discard them, and an overview of sign-ups and invitation codes with their remaining places. Each shows figures, never what people store.

  • From alpha to beta. The beta begins once the new architecture is in place and two to three weeks of intensive internal testing are behind us. More users join by invitation then.

  • New interface and architecture. The new version is running in the development environment alongside the existing application. Memory facts and the knowledge map, Support and staff administration are implemented there. The production application has not switched to v2.

  • Work continues on the overview, apps and access keys, file uploads and reliable updates across views. Before the switch, we still need to verify the complete interface and plugin workflows, performance, security and operation in production. The two interfaces will run in parallel only until the full replacement has been checked; the old application will then be retired.

  • Native integration of AI apps. Evidence with real clients for discovery, skills over MCP and change notifications; the protocol migration runs with the agent path of the new architecture.

  • Contacts. A plugin of its own for people and relationships with private notes.

  • All content in one database. Existing content has been fully copied into the database and checked for completeness. The application now reads and writes content exclusively in PostgreSQL; remaining S3 code and old S3 data are being retired in controlled stages.

  • Rights in the database. Who may see what is checked by the database itself, not only by the application; the foundation of the new architecture builds on it.

  • The newest MCP extensions. meinKontext is to use what the MCP standard has added recently wherever your AI app supports it: skills on the published standard, plugin views such as your calendar or task list right inside the conversation, long-running imports that keep going in the background, and a description of the server an app can read before it connects. Apps without these extensions keep working as they do today.

  • Reports in tasks, calendar and messages. Unowned work, what you are waiting on, what was finished this week; time in meetings; open requests and response times. Available to your agent now; the views come with the new interface.

  • Roadmap from meinKontext itself. This page is moving into a project in meinKontext's own task list, from which it is then published unchanged.

  • Sharing, rethought. See what someone will see and may do before you grant access; hand over responsibility for an area in an orderly way; a clearer interface for access and sharing.

  • A support bot in Slack. During the internal test, a bot in Slack takes bug reports with screenshots, feedback and ideas, checks them against what is planned, records what fits and later tells you what became of your report. Your reports stay in meinKontext's own support area, where only the support team sees them.

  • Noticeably faster. The platform is being rebuilt from the ground up; pages and responses that are slow today become fast with it. Until then the optimisations are missing.

  • Light, dark or like your system. A colour scheme you choose or that follows your device.

  • A component library for the new interface. The building blocks of the new interface (buttons, fields, menus and so on) get clear levels, from the smallest element up to the whole page, and are collected in one documented library, so every page and every plugin looks and behaves the same. The library and its browsable catalog with checks for accessibility and appearance are in place; the plugins are being moved onto the same levels.

Planned

  • Sharing built around your own context. Your own context stays at the center: shared areas show up in a clear place among your own, and what you share never ends up somewhere you didn't put it. Teams come as an optional add-on on top, for groups that want a shared space of their own. How exactly this is organized is still being decided.

  • Events with purpose, agenda and links. An event carries what it is about, what to prepare and which project it belongs to; your tasks' due dates appear in the calendar. Your agent prepares events and creates follow-up tasks from them.

  • AI apps use meinKontext on their own. A setup recipe and native features so that Claude, Codex and others include your context without being asked.

  • Open acceptances for integrations. Evidence with real accounts, two AI apps, repeated attack tests and an external security review; the features are built, the checks are missing.

  • Knowledge as plugins: wiki, sessions, meetings. The wiki becomes a standalone plugin; sessions and meetings become knowledge sources of their own from which insights can be compiled.

  • Security review before release. An independent review checks the integrated new architecture and final deployment configuration before real users access it. Open high or critical findings block release; remaining risks are explicitly assessed and accepted.

  • Your agent sessions as memory. AI apps that support it are to set themselves up to send a short summary of every working session to meinKontext automatically, and the knowledge from those sessions is to flow into your wiki with references back to where it came from.

  • New interface after the foundation. First parts of the new interface exist as a test version with test data; work on it continues once the new foundation underneath is in place. Today's pages stay reachable until their successor is ready.

  • Links that work for everyone. Every address names whose item it is, with a short handle for your account that is chosen for you and that you can change. A link you copy to an object, a memory entry or a record opens exactly that item for anyone you shared it with, keeps working after a rename, and shows nothing to people without access. Existing links keep working.

Backlog

Recorded but not yet commissioned: whether and when it comes is open.

  • Your agent answers for you. Only with pre-approved, predictable information such as free/busy, never with free text.

  • Guardrails for agents. When you let an agent use a connected service, you could also set conditions for it, for example that a pull request is always a draft or that a comment is required. meinKontext would check them itself and refuse a call that breaks one.

  • Your agent talks to another person's agent. Offer a role, link context, receive an explicit answer; everything with outside effect is approved by you.

  • Agents in messages, also on your behalf. An agent with its own access reads and writes in conversations; someone visibly writes in your name. Only after the security checks.

  • Develop a business model for meinKontext. Up for discussion: for whom the platform should prove a recurring benefit first — individuals, a small team with shared project knowledge, or organisations. Before anything is fixed, a real work scenario should show whether the promise holds; no segment has been chosen.

  • More calendar features after the rebuild. Once the calendar runs on the new architecture with everything it does today, a follow-up package can add participants and replies, recurring events, import and export, a conflict preview when moving events, reminders, free/busy times, finer rights, drafts for proposals from outside, reports, and a limit that asks you to narrow very large date ranges. Recorded, not yet commissioned.

  • Context marketplace. Up for discussion: people who build good skills, wikis or other context packages could sell them directly, and buyers would have them available in their own meinKontext right away.

  • End-to-end encryption. Under research: self-hostable, without depending on a vendor.

  • Infisical as a connection. The platform's secrets service as an ordinary MCP integration once it offers a suitable endpoint.

  • External services instead of or alongside plugins. Whether, say, Google Calendar can replace the calendar plugin or both work together is reviewed per plugin.

  • A shared memory for firms. An application on meinKontext for client knowledge in a team; needs the enterprise layer and a pilot partner.

  • Create context objects in the web app. Today a skill, an instruction, a subagent or an integration can only be created by a connected AI app. You could then also create one yourself under Context objects, with a form for each kind.

  • Offer tasks and accept events in a conversation. Send a task as an offer and the acceptance becomes an assignment; an invitation arrives as a message and the reply lands in the event.

  • Request tracing across services. To find slow or failing requests faster, we want to follow a single request through every part of the platform, with the data staying on our own servers.

  • Plugin views as machine-readable specs. Recorded idea, not commissioned: plugins could offer their pages not only as web views but also as structured specs over MCP, so that clients with generative-UI support can render them and every other client can read them as data. The idea comes from a team discussion around an external generative-UI framework; nothing is decided or built yet.

  • Reminders and schedules. Let a plugin do regular work for you without a model in the loop: be notified before an event, receive a report regularly, and see open items from other services, such as pull requests waiting for your review, among your open actions. Possible once the new architecture is in place.

  • Plugin SDK for external developers. Publication from the beta at the earliest, after a complete review of the SDK and once someone outside actually wants to build a plugin.

  • Fast search in large accounts too. Searching your knowledge and your wiki articles stays quick however much you store, also for rare words that appear in only a few articles.

  • Run meinKontext yourself and still share. Under examination: whether you could operate your own installation and share content with people on other installations, and which approach would be practical for that.

  • Relevant skills for the current task. Keep large skill libraries manageable: explore work profiles, targeted discovery and loading on demand. First measure what each client actually includes in its context.

  • A layer for agent swarms to work through. Idea for discussion: a customer commissions work in their familiar chat, and a layer above meinKontext organizes the whole delivery between the customer's and the provider's agent swarms. meinKontext stays the shared memory and the license broker for knowledge, a separate services marketplace sits beside it, and payment and performance evaluation would run on the top layer, not on meinKontext.

  • Teams and organisations. meinKontext stays a product for individuals first; an enterprise layer follows.

  • Tool evaluation only with your consent. To find errors and slow answers, we measure how the tools perform. We use the content of your calls for this only if you explicitly agree; you can change that in your account at any time.

  • Agents write wiki drafts, you publish them. An agent could write drafts in a wiki that only appear once you have reviewed and published them.