This is a framework I've developed for both myself and others that structures how humans — knowledge workers in particular — can work with AI as a co-operating system.

csAIi stands for Context, Skills, Agents, Integration and Iteration. These five layers comprise a framework and discipline for understanding how to work with agentic AI systems and how to develop them to complement and enhance the productivity and uniqueness of the user.

I have been actively developing and putting this into practice since June 2025, primarily with Claude Code and Obsidian, but the principles have been tested and applied to Microsoft Co-Pilot, ChatGPT and others. In the 'In Practice' section, I demonstrate how I put this into daily use. This is not just theory — it has been put through its paces.

What's in each section

csAIi Framework — The methodology. Five layers for AI adoption that compound over time.

Context — The foundation. Where every AI system should start, and where most people skip.

Skills — Repeatable procedures. Lessons encoded so they're not relearned.

Agents — Specialised roles for domains requiring judgement and variation.

Integration — External connections. Where the layers connect to real tools and services.

Iteration — The feedback loop. What makes the system compound rather than stagnate.

Philosophy — The thesis: AI works best as a sustained relationship, not a transactional tool.

In Practice — Live demonstrations of the system running in daily use.

Use the panels at the bottom of the screen, or if you're on mobile, navigate like an old-school iOS app. Each section builds on the previous, so by the end you'll have the basic theory to start building your own agentic disciplines and workflows.

Jim Christian

Cerebro is what happens when you follow csAIi to its logical conclusion. It started as a context file and a few skills. A year on, it has 41 specialised agents, more than 70 documented skills, and covers 9 domains — from content publishing to consulting to home maintenance.

It runs on Claude Code with an Obsidian vault as the knowledge layer. Every agent exists because I needed it. Every skill because I did something manually enough times that automating it made sense. Thirty years of domain experience across technology, security, content, and business informed what to build and how to structure it.

The system isn't smart in any meaningful sense. It's good at detecting patterns, following documented procedures, and making informed decisions within boundaries I've set. When it makes mistakes — and it does — I correct them, and those corrections get encoded back as rules for next time.

What's important to realise here is that what you'll see is highly customised to my particular way of working — so to someone not familiar with the terminal or markdown files, this might look like matrix-level wizardry, when in fact it's not. It's awareness, logging and breaking down problems at its most basic level.

With this kind of system in place, each person in your organisation can potentially have a bank of agents working for and reporting back to them — and each other.

Developing a co-operating system is a great way to learn your own strengths, weaknesses, plug gaps and be ready for whatever AI throws at us next.

This is the first foundation level of csAIi. Everything builds up from here.

Context tells your AI stack what it's working with and who it's working with — what the inputs are, what the expected outputs are. At a basic level for prompting, it's turning "write me a blog post" into something that considers the elements of circumstance: Who are you writing for? What are you writing about? Why should anyone care?

Context can be as simple as a text file defining your objectives. It can also be as complex as weeks of daily patterns, where working with a co-operating system creates context back and forth with the user. It can take the form of a constitution between you and the system — telling it what you expect. Or it can take the form of a validation framework, run at the start of a project to increase the chances of success.

Context is where everyone should start, and where most people skip — because we've been led to believe that AI will solve problems for us, rather than empowering us to solve problems with AI.

Related

Skills are, in essence, repeatable automations — actions that rarely deviate when run. In other words, the boring stuff, and things that can often get overlooked.

They can be as simple as checking your email and calendar and giving you a report based on the contents. Or they can run a full SEO audit on web content and generate a report.

When you start to think of your work in terms of skills, things become easier to compartmentalise and troubleshoot. Take web development: opening an FTP manager, navigating to the correct folder on local and remote servers, transferring updates, entering credentials. If all of that could be wrapped into a skill with the use of AI, the time saved adds up.

Skills at a base level aren't new — we see these time savers as macros, text expander snippets, automator actions, even workflow automations. But the evolution goes from thinking about them as your own toolkit to a toolkit that you can share with your agents — and we'll cover that in the next section.

Related

Agents are the third layer in the csAIi framework — and the one most people try to build first.

Agents are given a name, a description and a role, as well as a list of tools and skills that they're allowed to use to carry out their task. And we converse with them using natural language.

If we take some skill examples from the last section — where you might have one skill that checks your website for SEO and another that uploads the site to production — you could create an agent that does both when you ask it: "Hey Webster, check the website for SEO, make corrections and upload the changes for me."

Agents can work with skills that you create, and also create skills for you. One of the most important things you can do when working with agents is ask what they're capable of, and where they see other tools or integrations to work more efficiently.

Building agents too early, before you have context and skills in place, is why most AI agent projects produce impressive demos but limited daily value.

Related

This is perhaps one of the most equal parts fun and risky areas of csAIi, and requires good security policies that everyone adheres to and respects. It's also one of the most powerful areas of creating an agentic AI co-operating system.

This is where your system works with other tools and services — locally on your computer, or cloud services, APIs, command line tools or protocol servers. With integration, you can get your agents to:

• Pull monthly website analytics through an API and create reports automatically
• Post newsletter content straight from the command line
• Write command line tools to read PDFs, ePubs and synthesise information
• Automatically update documentation, pages and tables in external tools
• Use a web browser on your behalf for testing or automating form submissions

At this layer you can even start getting your system to delegate work to other systems — farming out mechanical tasks to cheaper or faster models.

This is where the benefits of understanding context, skills and agents really start paying off. Integration is the payoff — but only after the first three layers make it meaningful.

Related

Just like having a team of people, creating your own banks of skills, agents and integrations requires a maintenance overhead — not just from a technical and security perspective, but because we're human beings. We change our ways and practices and adapt to new things along the way. A solid system should reflect that, and we can do this with — you guessed it — context, skills and agents.

After just two to three weeks of conversing with a system like this, and doing a daily logging practice, you can start to ask it to look for gaps, daily patterns, areas of improvement. You can create skills that produce moratorium reports after working sessions — looking at what went wrong, what the user expected, and how to improve in the next session.

Every day when you're finished working with this system, you log what you've done. At the end of the week, month or quarter, you can analyse gaps, patterns and behaviours you may not have expected.

Iteration is what makes AI enablement work for and with its users at scale, six months after it's been put into place. It has to grow and learn with the user and not stay static. Anyone can set up an AI system in an afternoon. The question is whether it's better six months later than it was on day one.

Related

csAIi is a relationship and discipline framework for working with AI technology. It's not about the technical architecture — it's about how you structure and sustain the partnership between human expertise and AI capability.

Most AI adoption starts with the flashy stuff: agents, automations, integrations. csAIi argues that's backwards. Without context, your agents don't know who they're helping. Without skills, your agents reinvent solutions every session. The five layers — Context, Skills, Agents, Integration, Iteration — have a build order, and skipping it is why most AI initiatives produce impressive demos but limited daily value.

The Five Layers

Context — Persistent configuration that teaches AI who you are, how you work, and what matters. Instead of re-explaining your situation every session, the system already knows your projects, your preferences, your constraints. This is the compound interest of knowledge work, and it's where most people should start.

Skills — Reusable, documented procedures the AI follows when invoked. If you can write it as a checklist, it's a skill: clear inputs, clear outputs, same steps every time. Skills are simpler than agents, more maintainable, and where most of the practical time savings come from.

Agents — Specialised roles for domains requiring judgement and variation. You delegate a domain and the agent handles problems within it. Agents are for what's left after you've solved everything simpler — and most people build them too early.

Integration — Connecting everything to external services and creating automated loops. Calendar, email, databases, APIs. How your tools connect matters more than which tools you choose.

Iteration — The feedback loop that makes the system compound. Systematic self-reflection, encoded corrections, regular reviews. Without iteration, you build a tool. With it, you build a practice that improves over time.

Why this matters for enablement

csAIi gives people a progression. A new user starts with a context file and a logging habit — two things they can set up in an afternoon. After two weeks of that compounding, they're ready for their first skill. Eventually, skills that require judgement get promoted to agents. Integration comes last, because connecting a system that doesn't work yet just creates faster failure.

The framework is platform-agnostic. It works with Claude, ChatGPT, Gemini, or local models. The mechanics differ between platforms, but the architecture is identical. That makes it teachable across teams with mixed tool preferences.

Most users need a context file, a logging habit, and a weekly review. Three things. Use them for two weeks before adding complexity. The system should feel lighter over time, not heavier.

Most AI implementations treat the technology as a supplier. You ask, it answers. The session ends, and the next one starts fresh. Every conversation is a first date.

A co-operating system is what happens when you treat AI as a collaborator instead. You invest in teaching it who you are, how you work, what you value. In return, it gets better at helping you — not because the underlying model improves, but because the context you've built compounds over time.

The human in the loop is still essential. You can't trust answers blindly — verification is part of the practice. Computers are still doing what we tell them to do. For every automation we build, we also need to factor in where it breaks and what contingency looks like.

When you have a diverse organisation with people working across different contexts, cultures and ways of working, any AI co-operating system should be designed to take this into account. Taking a system off the shelf without understanding the needs of the user is somewhat doomed to fail.

The biggest challenge isn't technical — it's relational. People need to understand what AI can do for them specifically, in their specific context, before they'll invest the time to build something lasting.

Jim Christian

AI Enablement · Valencia, Spain

I'm Jim — thirty years in tech, the last few at the AI end. I help freelancers, consultants and small-business operators put AI to work in the business they already run, instead of rebuilding from scratch.

If something here sparked an idea — or you'd just like to talk about AI as a co-operating system — I'd welcome the conversation. The quickest way in is the community, but my door's open either way.

If the thinking here landed, this is where it keeps going. csAIi is the framework — but a framework is easier to follow when you can ask questions, compare notes, and watch other people work things out in real time.

Two ways to stay close to it, depending on how hands-on you want to be.

Superpower Circle

A private community for freelancers, consultants and small-business operators who already know how to run a business — and want AI to be a real tool, not another thing to feel behind on. I run it with Maya Middlemiss.

Each week Maya posts what she actually shipped with AI — the prompts, the failures, the outputs. I drop walkthroughs with the boring bits left in, so you can follow at your own pace. People ask the questions they were embarrassed to Google, and we work them out together. No grades, no homework, no "AI ninja" anything.

€49 a month. No contract. Cancel any time.

Signal Over Noise

Want to start lighter? Signal Over Noise is my newsletter — the same kind of thinking and explanation you've seen here, delivered to your inbox. Less noise, more signal, no hype.

Loading articles...