Speaker A
Hey, wipecoders and neuroenthusiasts. In this video, we'll explore Deep Harness. What it is, who needs it, why it's needed, and why, in my opinion, most reviews currently present it incorrectly. So, what is Deep Harness?
An in-depth review of Deep Harness, its architecture, customization, and how it differs from other AI agents like Claude Code.
Key Takeaways
- Deep Harness transforms language models into actionable agents by providing a customizable plugin-based framework.
- It is open-source, unlike many commercial AI agents, allowing deep customization and extension.
- The core strength lies in its modular design, enabling users to tailor the agent to their specific needs.
- Existing reviews often miss the deeper value of Deep Harness by focusing only on its user interface.
- Deep Harness supports multiple deployment options including desktop and web interfaces.
What the video covers
- Deep Harness is a framework that extends language models by providing tools called harnesses to enable action execution beyond text generation.
- The language model acts as the brain, but requires plugins and tools to perform meaningful tasks, which Deep Harness facilitates.
- Unlike closed systems like Claude Code, Deep Harness is open-source and highly customizable through plugins.
- The video explains the analogy of Deep Harness as Linux compared to Claude Code as MacOS, emphasizing flexibility and customization.
- Deep Harness can be run via a desktop app or web interface, with installation instructions provided.
- The architecture relies heavily on plugins that implement all functionality, allowing users to replace or add features easily.
- The speaker critiques existing reviews for focusing too much on superficial UI features rather than the underlying framework.
- The video covers the structure of Deep Harness, plugin management, and how the agent executes commands in cycles.
- There is a discussion on the use of GitHub for accessing and modifying the open-source codebase.
- The video also touches on practical usage scenarios, including running the agent on local machines and configuring it for specific tasks.
Chapters
- 00:00Introduction to Deep Harness and its purpose
- 03:31Comparison of Deep Harness to Apple technology and Linux
- 07:12Customization through plugins and replacing features
- 10:54Overview of the desktop application interface
- 14:26Discussion on payment models and token consumption
- 21:29Plugin presets and global plugin overview
- 29:26General architecture and internal workings of Deep Harness
- 40:34Running Deep Harness: web interface and command line options
Full Transcript — Download SRT & Markdown
Speaker A
Well, judging by LendOS, it's some kind of agent, but it's not that simple. Actually, the word "harness" is key here, and harnessing is the framework around the model. Before we move on, I want to clarify this point. The
Speaker A
language model itself is the brain of the agents, but it doesn't really do much. Basically, a language model receives some data as input, often text, and produces text as output. And that's it. Yes, some models can also
Speaker A
generate images and, say, receive the same images as input, but that's not the crucial point right now. The important thing is that the model doesn't perform any actions. And this is essentially where all the Neron hype started. When we had a simple chat,
Speaker A
we'd write some prompts there and get a text response from the neural network. To turn such a chat into a fully-fledged agent capable of performing certain actions, we need to give the model the appropriate tools and teach it how to use them. These
Speaker A
tools are essentially called harnesses. That is, unlike a regular chat, where we write models and prompts and get text as output, we give the model the ability to use certain tools, like memory, subagents, skills, and so on.
Speaker A
This diagram looks like we're connecting all these tools directly to the model, but in fact, it's more accurate to depict it a little differently. Here's how it works: in addition to the text data of some of our prompts, we also provide
Speaker A
information about the corresponding tools as input. Moreover, we provide this information in the same text format, meaning the model still receives text as input. In addition to the prompt we send it, it also receives information about the tools it can use.
Speaker A
The model outputs the same text, but now it doesn't just reply to us in chat; it tells us what action needs to be performed. It knows about the actions it can perform and the tools it can use
Speaker A
because we told it that at the very beginning. So, it simply tells us which commands and tools need to be called.
Speaker A
Then, on your computer or wherever the agent is running, these actions are executed. And when these actions are executed, the result of these actions is sent back to the model. This happens in the next step. So, in the first step,
Speaker A
the model responded with the tools it needs to call. We call them and send the model another request with our prompt, the chat history, and the tool information. And the result of the completed action is also added to this.
Speaker A
After that, the model can either return a final response or request another action. And this cycle continues until, well, the model considers the task complete. So, all these capabilities and tools we give the model are called harness. Harness literally translates
Speaker A
as a harness, so to use it like a horse: yes, a horse has strength, but to turn that strength into something useful, you need to harness it and, I don't know, plow a field or something else. Go dog Harnessness, that's the
Speaker A
analogy, yes, from a horse, that's exactly what it's about. It's the harness we can attach to our horse. The horse in this analogy is some kind of LLM language model that can simply output text and do something useful
Speaker A
with it. And here you can draw an analogy: CLDcD is like MacOS, and Deep Harness is something like Linux. That is, when we open the code, everything is there out of the box. And it's really well done. That is, when you use
Speaker A
Apple technology, you don't want to change all that stuff or mess around with the tech. You just enjoy using it.
Speaker A
You open up, I don't know, your iPhone or MacBook, and just enjoy it. Deep Harness is Linux, meaning its customization options are much greater.
Speaker A
And basically, it's designed as a kit, that is, a kit of agents that you can build to suit your needs. I would view the Harness nutcase roughly as follows.
Speaker A
And whether this is good or bad, whether you need it or not, we'll try to figure out in this video. Before filming this review, I watched quite a few reviews of Deep Harness, and most of them simply show the web panel of this
Speaker A
agent. Well, now there's a desktop version. Here it is. It wasn't available for a while. There was a similar panel, only it opened in a browser. And that's great, of course.
Speaker A
We'll also look at all these interfaces today. But we won't limit ourselves to this, because, in my opinion, it's like showing off a new smartphone model and saying, "Look, it can make calls and you can change the wallpaper." Well,
Speaker A
that's obvious; all smartphones can do that. But the beauty of Deep Harness lies a little deeper. And I'll try to uncover all the charm and uniqueness of Deep Harness compared to other devices and agents. In simple terms, without
Speaker A
delving into complex code, but so you understand what it is, how to use it, and whether you need it at all. First, of course, we need to launch Deep Harness. As I already said, a desktop app has recently appeared. It's
Speaker A
available for MacOS and Windows. Let's download it right away. And besides the desktop app, Deep Harness also has another option for launching this harness. I think this is also important to look at, because later, based on the second method, we'll have an
Speaker A
interesting analogy that will, among other things, reveal the full power of this Deep Harness. So, let's look at that now too. If you scroll down, you'll see four buttons. Well, right now they're located here: GitHub and Developer Docs. Let's open both these
Speaker A
pages at once, GitHub and Developer Docs. And this will open a file in the GitHub repository with a description of how to launch Deep Harness. If this is your first time hearing the word GitHub and you don't know what Git is,
Speaker A
I'll explain it briefly, because this might also be important to understand. GitHub is like, well, Instagram for developers, mixed with Google Drive, right? So, Google Drive as a code storage, but not just for personal use.
Speaker A
Here you can publish your projects for, well, public viewing, so anyone can look at the code, download it, use it, and suggest changes. And Deep Harness is an open-source tool. It's located in an open GitHub repository. Here's Deep Harness,
Speaker A
which we opened earlier. Here's the entire project code. You can see how it's structured. You can download it if you want, and you can even edit it if you really want. But there's little point in editing the Deep Harness
Speaker A
code itself, because Deep Harness itself is just the core. Everything that works in Deep Harness is implemented through plugins. And Deep Harness's position is that you don't need to suggest any changes to the code. You just write plugins and
Speaker A
share them. So, all customizations, and in fact, even the basic functionality of Harness, everything that's there, is implemented through plugins. These are the building blocks that make up Harness. Using these blocks, we can customize the agent exactly as we need.
Speaker A
We can replace some fundamental features simply by writing and replacing the standard plugin with our own. This means that absolutely everything is customizable, unlike Cloudcode, Codex, and other agents, where all the hardware is built into the product itself, and customization
Speaker A
is pushed to the top level by adding various skills, MCP, and so on. We'll definitely look at how this works in detail. But for now, let's finish with the installation. If we want to run Deep Harness in the web interface, that is,
Speaker A
in a browser, we have two ways to do this. The first, and simplest, is to use a single command, either in the terminal on MacOS or PowerShell on Windows, or the standard command line.
Speaker A
It's better to use PowerShell, as it's more powerful. We can simply copy this command, paste it into the terminal, wait a bit, and then—oh, well, we still have to agree here—press Y, and the web interface will open, through
Speaker A
which we can work with Deep Harness. Besides this command, there's another way: c
Speaker A
Essentially, download all the source code for this DPC Harness to your computer and run the code we downloaded . You only need to do this if you want to edit anything in the code. We won't do that in this video. We don't need to
Speaker A
delve into the code, and everything we need is customizable via plugins. After a short while, the server running the Deeps Harness web interface starts. You can access it at this address. And the page opened automatically for me. Here
Speaker A
we're greeted by a warning that Deep Carness is currently in preview, and there will be some breaking changes, some plugins, or the format may eventually cease to be supported because the interface will change, but that's not really important to us right
Speaker A
now. This suggests that, uh, DPC Carness is actively developing, and what it will become over time remains to be seen. It's possible it will change dramatically, but for now, we have what we have, it's already usable, and that's already interesting. Next,
Speaker A
we need to add a brain to our psycharness. Well, that is, we have this harness, and we need a horse to make it all work. First, let's install the desktop application. It's very simple. Run the file we downloaded from
Speaker A
the DeepSic harness website and drag it into the Application folder. Well, this is on a Mac. On Windows, the installation is as familiar for Windows users as on a Mac, for MacOS users.
Speaker A
Well, basically, drag it into the Application folder. Now we can launch it. I press Command Probe and type "DPC Carness" here. Now we have an application available that we can open.
Speaker A
The following interface opens. Here we are asked to either log in or add an IP key. I'll click "Sign In," because I'm already registered with Deepseek, and registration is easy via email. There's no need to verify any phone numbers, so
Speaker A
I recommend you also register and log in. Now, I'm getting a six yuan bonus, I think—we'll see for free now—and they can be used for some DPS Carness testing. So, we confirm all authorizations. Next, we're greeted by this welcome message in Deeps Harness.
Speaker A
And let's click "Get Started." About credits, I think. Let's continue. Uh, you can select certain parameters here.
Speaker A
We'll use them for coding and development. Next, we need to answer the question of how many details we want to see. Let's choose "full details ." And open the application. That's it.
Speaker A
We're opening a desktop application. The interface is probably quite familiar to you. You might have seen a similar interface in Codex, Clodcode, or even just Clod. Basically, it's a pretty basic story. The agent also has a prompt field. You can select a
Speaker A
workspace, which is the folder the agent will work in. In this session, you can choose access: read-only, work in the workspace, which means editing files, or full access. Well, for now, we'll settle on the middle ground: Workspace W without full access. Yes,
Speaker A
you can choose the model. There's also a mode selection here. Now that's interesting. We'll get to that very soon. Before we go any further, I want to say that in this video we're looking at the DeepSek Harness. But if you want
Speaker A
to learn how to create web applications and don't know where to start, or are stuck somewhere between "I have something running on my computer" and a live product online, then I invite you to take my web application development
Speaker A
course. Unlike YouTube, this course contains over 80 lessons that thoroughly explain everything and cover all the blind spots you might encounter when developing web applications.
Speaker A
You'll learn how to launch your web applications from scratch, literally by installing all the necessary software.
Speaker A
We then explore the various pitfalls of effective wipe coding and how to create an application that won't crash for real users. We implement database authorization, payment processing, neural networks, and configure security to prevent your application from being hacked. In short, we walk through the
Speaker A
entire process from scratch to release. Finally, we implement analytics and statistics to track user behavior and optimize your application. As the person who recorded this course, I can say that many of these videos are simply not suitable for YouTube because
Speaker A
they won't get enough views. For some reason, everyone watches videos like " The New Klodko Code Killer" and the like, but there are no videos about setting up security. And this is evident in the video statistics on my
Speaker A
channels. You can see how many views a video about security has and how many views a video about the deck code has.
Speaker A
Well, draw your own conclusions. The point is, you're unlikely to find many of these topics on YouTube, because it's not profitable for me and other people who make similar videos to post them there. So, if you want to learn
Speaker A
how to launch your own web applications and are tired of searching for information online, I invite you to my course. Follow the link in the description, check out the detailed information, and if you have any questions, send me a private message,
Speaker A
and I'll tell you if this course is right for you. Now, back to the main topic of this video. If we look at the web version of Carness, it looks essentially the same, only it opens in a browser. Here in the settings, we can
Speaker A
also configure models, log in to our Deepsic account, or add a model provider. Here we can choose from available providers. There's a fairly large list here. We can also add a custom provider and enter the URL to which requests will be sent. For
Speaker A
example, if you want to use a provider that's not on this list, you can look up the base URL of the provider to which requests should be sent and enter it here. So we don't have to come back
Speaker A
to this later, let's try this. For example, we can use the Polza AI model aggregator. It's available in Russia, and you can top it up with Russian cards. You can also use Openter. We'll probably connect that too. It doesn't
Speaker A
accept Russian cards, but it does support crypto. I'll leave links to Polza and Openter in the description.
Speaker A
Here we need to go to the API keys section and create a new key. I'll call it DPC Carness video to avoid confusion later, and set a limit on its amount, say, 1,000 rubles. Although I think we'll spend much less today. Ah, create
Speaker A
a key. That's it, you can copy it. Let's return to Harness's Deepsi tab. We'll enter this API key here. We don't need to change the protocol for the benefit here. We just need to specify the base URL here. You can find it like
Speaker A
this. Just type "base URL benefit AI" into Google. And now the neural network will tell us what we need to enter. Yes , that's it. Copy it and paste it into the base URL. That is, if you use some
Speaker A
other aggregator, you can do the same. Display name, let's call it benefit. Provider ID, well, benefit II. That's it. Everything is ready. You can simply click the FCH available button and wait for the available models to load. We
Speaker A
just had an error, and I figured out what the problem was. I did enter the incorrect base URL here. We need the first option, this one. That is, here's a different address. I don't know where Google got it from. Maybe it works for
Speaker A
someone else there, too, but for us right now, the first one will do. We paste the current PS URL. Click on the model request again. And this time, we've got it all figured out. You can select the models we need here so you
Speaker A
don't have to add the full list, but I don't want to bother with that right now and will just click "selected." Everything's ready. We have a bunch of models from the AI utility there that we can choose from. And then we can go
Speaker A
ahead and click "create provider." Done . And we've added the provider. You can add Openуer here in a similar way. The only thing is, Openуer should most likely be in our pre-prepared models.
Speaker A
Here it is, Open Router. We also need to get an API key here. Go to the API keys section of Open Router. Create a new key. Basically, everything is done similarly. I'll add my limits here. You can add them or not, at your discretion
Speaker A
. Enter a password and create a key. Also, copy it and paste it into the corresponding field in the Deeps hardware. Click "apply." Why does it make sense to add both Openуter and UDP? Well, the thing is, there are
Speaker A
certain issues with the internet right now, with restrictions between different locations. Sometimes you're using a VPN, and you can't access the service there; sometimes you're using one without a VPN, and you can't access OpenRouter, and so on. To avoid
Speaker A
switching VPNs, you can switch providers. That's convenient, at least in my case. And you also choose a provider based on your location. That's basically it. So, we can then use this, choosing a model from different providers. So, let's say we have a
Speaker A
service. We can scroll down and choose a model from OpenRouter. Since we're working with a Dipsic, let's choose a Dipsic model, although that's not really necessary. You can also use Claude GPT models or any other. And I'll choose the Dipsic V41 Flash.
Speaker A
That's it. The agent will respond to us . Regarding the desktop version, where we're logged in with my account, if we go to the settings, we'll see, basically, that the PsyCap account doesn't work by subscription, but rather by the balance of the token.
Speaker A
That is, we have a bank balance, which was given to me for free upon registration. There's also a balance, which we topped up. Well, that's basically it. So, uh, there are no subscription tokens here. I think this positioning of DPC Carness, that we pay
Speaker A
not for a subscription, but for, well, essentially, consumed tokens, also says something. And what does it mean? And I'll share my thoughts on this a little later, when we approach it logically.
Speaker A
For now, let's just note that with the PsyCap account, we don't work by subscription, but pay for using tokens.
Speaker A
Is it possible to use DPC Carness by subscription instead of paying for using tokens? I believe it's possible, but firstly, not through a depsk account, but through a different provider. Secondly, I haven't done that . So, if we add a model provider here,
Speaker A
let's say there's OpenCode Go. And OpenCode Go, as far as I understand, is a subscription-based service. I honestly can't tell you about the limits and how it's calculated, because I haven't tried it myself. Besides OpenCode Go, there are probably other
Speaker A
providers here that also work on subscriptions. We won't go into that right now. We've sorted out how to connect an account and model providers.
Speaker A
Let's get back to the interface. I'll expand it to full screen for easier navigation. And here, in general, yes, it's a familiar interface. Sessions are on the left, and the prompt field is in the center. We can use DPC Carness,
Speaker A
like other agents, such as SD Codex, to write queries, select folders, create files, and wipecode. This is all great, but I don't see much point in going into it too deeply, because, well, it's essentially the same thing as in
Speaker A
Klodkovoki, in Codex, and yes, that same volume in Claude Codex. Essentially, the process of working through this interface is similar. But what's interesting here are these modes . We currently have four of them: Standard Mode, PTC Mode, Minimal Mode,
Speaker A
and Creator Mode. What's the difference , and why are they needed? These modes are also called presets. And essentially, they're a set of plugins that will be available to the agent in the current session. And if we remember
Speaker A
that in Deeps Harness, literally everything is implemented through plugins, then using these modes, and going further, we can create our own modes, we can choose the set of tools that will be available to our agent.
Speaker A
And that's really cool. This is what really sets DeepCness apart from other agents like Claude Code, Cowork, and so on. Let's quickly go over these modes now, and we'll go into more detail a bit later. The standard mode is very
Speaker A
similar to, well, a standard agent like Claude Code, Claude Code, or Codex. We'll look at the PTC mode a bit later, when we go into more detail about how it all works. Minimal mode, uh, this mode has a minimal set of plugins and
Speaker A
tools. It can be used, for example, to compare models. That is, if you want to compare the performance of two models, well, let's say, in a vacuum, under conditions as close to each other as possible, this is the ideal mode for
Speaker A
that, because in this mode, as far as I remember, the model only has a terminal available from the toolset and that's it. And it's clearly written here that this mode is well suited for testing and comparing the performance of
Speaker A
different models, because we not only run the models in the same environment but also provide them with a minimal set of tools. This way, we can look at how the model works, well, let's say, in a vacuum, how it works without any
Speaker A
third-party hardware. Because if we compare models, for example, from Claude and from Open AI in Claude code and in the Codex, well, firstly, these will be two completely different model environments. They will have different hardware, yes, different tools
Speaker A
available to the models. And even if we compare this, say, in Open Code, it will still be, well, the hardware of this Open Code. But here we can disable everything and compare bare models. In other cases, frankly, I don't yet know
Speaker A
why this mode is needed. Well, unless you really don't need anything else for your task except the terminal, then yes , okay, you can disable everything unnecessary and use minimal mod. The last mode, the last preset available here, is actually quite interesting—
Speaker A
Creator Mod. In this mode, the agent can not only perform actions, but also configure itself, edit plugins, configure configurations, and add plugins. And this is truly interesting, because, as we mentioned earlier, in DPC Harness, everything is built on
Speaker A
plugins, everything works with plugins, and you can use plugins to configure the agent. Moreover, plugins not only affect the model's behavior and capabilities, but you can also use plugins to customize the interface you're working in. Let's say, well,
Speaker A
let's write "Okay, hello" here. This will initiate a dialogue. Using plugins , we can generate buttons with pre-defined text above the prompt field , sort of like a continuation of this dialogue—not pre-defined text, but rather, the model will offer us a
Speaker A
suggestion for our next prompt. You've probably seen these tooltips in various , I don't know, interfaces with neural networks. They're not there by default here. We can add them with a plugin.
Speaker A
With a plugin, we can create a separate section here, with, I don't know, session statistics, where for each session it will show how many tokens it spent, how many requests, steps taken during the conversation—well, basically, everything you want. So, all
Speaker A
the information that's in the DeepSek Harness that it processes is available for use in plugins. And even more so, there are plugins built into DeepSek Harness for displaying the interface.
Speaker A
Basically, the entire work is built on these plugins. We can replace them with custom ones and redesign them—well, literally anything you want. And in Creator Mode, we can do just that using this same agent. So, instead of writing
Speaker A
and editing plugins manually, we can ask our agent to do it for us. And that's cool, that's interesting. You can see a list of plugins available in these different modes by going to the settings. There's an "Agent Presets"
Speaker A
tab here. Here you can see that we have four of these presets. And in each of them, you can view the configuration.
Speaker A
Here it is. Essentially, this is a config file, which I don't suggest you edit manually, although, in principle, you can. It tells you which plugins are used in each mode. You can also create your own preset here. If we click this
Speaker A
button, a new session will simply open in what should ideally be a Cray mode.
Speaker A
In Creator mode, we can simply ask it to create a new mode. Let's say we call it "Review," and we'll do that a little later. In this mode, the agent won't be able to edit any files or make any
Speaker A
changes at all. It will only be able to read, and you can configure some additional capabilities or requirements for it. Now let's go back to the settings and look at the Buildin plugin tab, which is the built-in plugins, and
Speaker A
see what plugins these presets have. There are two sections here: session plugins and global plugins. Session plugins are the plugins that are enabled in the selected preset. That means mode, PTC mode, and minimal mode.
Speaker A
Let's switch to minimal mode. It only has six plugins. If we switch to Standard, it has 29. Creator mode has 30. These are the plugins that depend on the selected preset. There are also Global Plugins here, many more of them,
Speaker A
186. And these are the plugins that basically allow DPC to work with Harness. As I already said, literally everything is done through plugins here , right down to the interface through which you, well, we're now interacting with Deep Harness. You can, of course,
Speaker A
look at all these plugins, but there are quite a lot of them. We won't do all that. These are just basic plugins that allow deep learning to work. We'll close this for now. There's also a " plugins" button in the sidebar. If we
Speaker A
click it, we'll go, yes, to the plugins section. Here you can enable official plugins. Well, there are eight of them that we can enable right now. Let's say , automation task. If we enable it, we get another tab, "Automation Tasks."
Speaker A
Well, that's how it works. And yes, this is an official plugin, but no one's stopping us from writing our own, which would add a separate section here , through which we can do anything with our agent, in this case, create
Speaker A
automated tasks. This should work similar to the task schedule in Claude Coworking, I think, the routine schedule in Claude Code. Well, this has already appeared in other agents too.
Speaker A
They're just called slightly differently. So here, if we click "new, " we're redirected to a new chat. And I think this is just, well, some kind of oversight on DeepSic's part, because, well, it would be nice to at least
Speaker A
write some basic prompt here, because right now, well, all that happens is that Creator mode opens. And here we can essentially tell it, well, something like: "Create an automation task," which will run every day at 8:30 PM, look up the latest article on Huber
Speaker A
, and tell me its name. Obviously, this is a completely useless task, but nevertheless, this example allows us to at least see how automation tasks are created. Although, in principle, there is nothing supernatural here. Just like schedule tasks, you can create them
Speaker A
from chat. Here it can be created from chat, there in Creation mode. There you go. Here, DeepSic created this task for us. We can see it there in Automation Task. It also appeared there every day at 8-30 PM. Everything will run. Cool.
Speaker A
It's clear we could do something useful here, at least, I don't know, collect some of the latest trends from this Habr or something. They're just paraphrasing the name, but it'll do as an example. And that's about plugins.
Speaker A
We can use them to customize this agent , uh, build it from the builder however we want, literally anything we want, anything we need. There's also an addplugin button here, and if you click it, we can add a plugin here, either
Speaker A
from the official npm registry or a mirror of some Chinese one. You can also enter a custom npm address where it will be taken from. We won't be making anything up right now. There's an example here, so we can use an
Speaker A
example, well, one that's perfect for an example. Let's install it and see what happens. Done. The plugin is installed, and we'll enable it right away. And now we have this pet that we can place somewhere in the interface.
Speaker A
Of course, this is just a joke, but we can do literally anything with it. And in the list of installed plugins, we have this newly installed plugin; we can disable it or enable it. That's basically it. Where can we find
Speaker A
ready-made plugins? Well, first of all, if we go to the Deep Harness landing page, we'll see a "Community Plugins" button at the bottom. This will open a GitHub page, which contains quite a few plugins for DPC Carness. Currently,
Speaker A
there are 18,000. You can search there. There's also the Osome DPC Carness plugin resource. It also contains quite a few plugins, currently almost 4,500.
Speaker A
And if we click the "install" button, we'll see a command that needs to be run in the terminal on macOS or in PowerPoint on Windows to install the corresponding plugin. There's also DSH Market, which you can use to install
Speaker A
plugins later. It's a plugin for installing plugins, making installation more convenient. It's just like that, yes. As you can see, the command is similar: DSH, plugin, then specify the profile. Here, if we want to install it for the web version, we specify "web."
Speaker A
If you're using the web interface, or the desktop version, you need to specify "desktop" here, followed by the plugin name. That's basically the formula for this command. You can also install plugins from GitHub. So, for example, if you found a plugin on
Speaker A
GitHub, you can add GitHub, a colon, owner, and the repository at the end, rather than the plugin name. Now let's install the plugin market, but for the desktop version, not the web version.
Speaker A
For the desktop version, we need to change the profile to "desktop" so that the plugin is installed specifically for the desktop application. Ah, but before we do that, we need to add this DSH command to the terminal so we can
Speaker A
run it there. To do this, in the desktop app, if we click on Deeps Carness in the tab bar at the top, a drop-down menu will open. Then we need to click on Manage DSH command. I don't know what this tab is called on Windows
Speaker A
, but I think you'll find it. It's under File, Edit, Windows, and so on. I already have it installed. If you don't have it installed, there'll be an Install button. Click it, and the command will be installed. After that,
Speaker A
to check, you can type DSH version in the terminal. Press Enter. It should display the version of this DSH command . If you don't have it installed, you'll get an error saying DSH was not found. If the version is displayed,
Speaker A
then these commands will also run for you. Let's copy and paste this into the terminal, and the DSH Market plugin should be installed for the desktop profile. So, when we launch the desktop application, the desktop profile is enabled. The installation is successful
Speaker A
. Let's go to our desktop application, to the settings section. And here we now see a new tab, Plugin Market. Here you can also search for plugins and install them directly from here. It's easier than doing it through the
Speaker A
terminal. But in any case, it's important to note that it's better to install plugins that you, well, for some reason, trust. Either you've reviewed the plugin's code on GitHub, through Neural Network, or you've done it yourself. Or at least this plugin,
Speaker A
or more precisely, this repository, has enough stars to be trusted. So, if the community trusts a plugin, it's likely that it wasn't developed by hackers, but by genuinely good people, and you can use it. You need to approach this
Speaker A
with caution, because attackers can inject malicious code into plugins, and you could lose data, your sensitive data could fall into the hands of attackers, and so on. Basically, you could face some negative consequences.
Speaker A
Therefore, when installing plugins, be careful only installing those you trust . For example, installing a plugin from the plugin market, let's install a taskboard. You can click on it, look at the repository, uh, the code, enter it into neural network, ask for a review,
Speaker A
but, in principle, it has 8,000 stars, so it's most likely normal. Let's try installing it. Confirm and wait for it to install. Done. The plugin is installed. And in the left panel, we have a taskard. And this is essentially
Speaker A
a Kanban board with which we can somehow interact. We won't go into too much detail right now, because, well, a breakdown of all the existing plugins for DepCрса is a whole other topic, probably for a video. To keep this
Speaker A
video short, we'll focus on installing the plugins for now and move on. I think you get the gist. There are a ton of plugins that extend the agent's capabilities, enhance the interface, and add new features. Installing them is quite simple. You can either use a
Speaker A
command in the terminal, or install this market plugin and install plugins through it without the terminal. We've covered installing ready-made plugins.
Speaker A
Now let's look at how to customize the agent using more familiar methods. Well , firstly, it supports rules and skills , which is basically how it works with other agents by default. Rules can be stored in the agents.m file. It can be
Speaker A
placed in the root of the project or in a subfolder. Or, if you want to write rules for all projects that will always apply, then you need to open the todS folder, which is located in the user folder, and create this file there. If
Speaker A
we go to the user folder, here we first need to enable the display of hidden folders and files. On MacOS, this is done with the keyboard shortcut Command , Shift, and period. On Windows, in the settings, under the View tab, check the
Speaker A
box "Show hidden folders and files in File Explorer." Here we need to find the ddsh folder. Here it is. And, well, this is where the agents.md file is created, in which we can specify the rules. The same story with skills. We
Speaker A
can store skills in the toSkills folder or in the dshskills folder. We can also make them global for all projects or specify them in the project folder so that these skills are available when working in this folder. As for slash
Speaker A
commands, there is no separate folder with files for slash commands. Skills can be used instead. Simply specify in the skill parameters that this skill shouldn't connect to the agent, or rather, that it should only connect manually, and then it can be called
Speaker A
with a slash. Well, let's say you add a slash. And here are some prepared skills; they were here by default.
Speaker A
Let's say we call a skill like this. And if it doesn't connect to the agent automatically, then, in essence, the skill can be used as a slash command.
Speaker A
Rules and skills are the simplest settings, where we put files in the appropriate folders, and they are available to our agent. The next level is editing the config. The config file is cordis.patch.yyaml. And in it, we can already write some configuration
Speaker A
settings. This file is located in the DSH folder, which in turn is located in the user folder. Here we can go to profiles. And here we have two folders: desktop and web. These are the profiles that are used. There's "web" for
Speaker A
launching the web interface, and " desktop" for launching the desktop. We'll talk about profiles in more detail later. What's important now is that, yes, there's a file called cordis.patch.yyaml here. Let's open it with the cursor, for example, or you
Speaker A
can use any other code editor. It looks like this. We've already defined some parameters here, specifically the Open AI and Open Router providers.
Speaker A
Essentially, what we configured in the settings is captured here in this configuration file. That's it. And here , you can actually define various parameters. We won't go into detail about this right now, because, well, that could be a whole separate video.
Speaker A
For now, I want to give you the general structure of how DeepsKS works under the hood and what you can do with it.
Speaker A
Then, using the agent and the documentation, you can dig deeper, but I don't really want to delve into the code too much in this video, so for now , we'll just cover these general points . In fact, we can already add some MCP
Speaker A
servers in this file. To add an MCP server, the following is specified in the Cordispatch Yam config. This specifies the name of the plugin that connects to the MCP—the official DSHMCP client plugin. And then, in the config parameter, the parameters of
Speaker A
this MCP server are specified. It's actually easier to do this through AI agents than to tinker with it manually.
Speaker A
But nevertheless, you can see how it looks in the config file. Now, regarding hooks. If you already have existing hooks, written, for example, for cloudcode, you can also connect them to DPC Carness. A separate plugin is also used for this. But if we're
Speaker A
talking about native hooks, they are also created using plugins. That is, instead of describing a specific hook, a plugin is simply created that acts as a hook and implements the same logic as a hook would. Next, you can use the
Speaker A
config to add your own mode, essentially your own preset. We currently have four of them, but we can add our own. For example, let's create a preset for code review that won't edit anything, but will only review.
Speaker A
We'll switch to Creator mode so our agent has the capabilities and tools to edit these configs. And we'll ask it to create a new mode for code review.
Speaker A
Here's a simple prompt we'll give it. This will be sufficient for this example. Next, you'll need to wait a while. Since the agent isn't running in full access mode, but in Workspace WR, it will ask us for permission, so we'll
Speaker A
need to click Next, Next, Next. After it finishes, we'll have a new preset that we can select when creating a new session. Done. The agent has finished creating our new preset. And now, when we open a new session, our custom
Speaker A
preset will appear in the preset list. It only reviews and doesn't have any editing tools. That is, even if he wants to, even if the model for some reason decides something needs to be edited, it simply won't have the
Speaker A
ability. Let's test this. I'll select the project folder, which I'll show you a little later. We'll select review mode and ask him to update something, say, rewrite the Redmi, add some details. The expected cast will be such that he simply won't be able to do this
Speaker A
. He won't have the necessary capabilities and tools for editing files. Done. Psi responded to us and immediately said that he doesn't have recording tools and is prohibited from making any modifications via the terminal. So, instead of fixing
Speaker A
something manually, he suggested we fix it ourselves. He offered a ready-made Redmi, and this is normal behavior; he responded to our request as best he could. So, we've added a new preset, a new agent configuration that we can use
Speaker A
when working with, well, Psi Harness. We've looked at creating our own preset . And what else do we have left in terms of editing the config? You can enable subagents 'codec IDCODE. So, Deeps Harness has its own subagents. It
Speaker A
can call them by default. Moreover, we can configure them in the plugins section. There's a Subagents tab here, and we can configure the maximum recursive depth of subagents, like a subagent calling a subagent, which calls a subagent. That's how many
Speaker A
levels we allow it to do this. We can also specify how many parallel subagents it can run simultaneously.
Speaker A
The default values are 1 and 8, but we can edit them. In addition to these built-in subagents, we can also include a subagent in Code-Code and Codex so that it can delegate certain tasks to them. Well, sometimes this can be
Speaker A
useful and applicable. For this, we'll need the appropriate plugins. As we remember, everything here is done through plugins. Here are their names.
Speaker A
You can install them, enable them, and use the Claude and Codex subagents. And the last category of customization is creating your own plugin. So, we can essentially do anything with the plugin —use it as an MCP server, sending
Speaker A
requests, receiving responses from third-party services, and then providing context to our agent. This could be a native hook that attaches to an event and, say, checks whether it's a file change or not, and whether it should be denied or approved. Hooks
Speaker A
come in all sorts. For example, checking for certain actions. It could also be a slash command, a native slash command—not a skill called with a slash. With a plugin, you can add a slash command and do something with it.
Speaker A
And we can handle it in completely different ways. It's not just editing a prompt triggered by a slash command. It could be running a script, code, anything. So, anything that can be written in code can be run via the ztu/
Speaker A
command. This is much more widely applicable than classic slash commands, like those in cloud code, which simply send some prompt to the agent's context . And finally, there's the UI widget.
Speaker A
We've already looked at this. We've certainly added some custom 10ation Tasks and taskards, but we can also ask it to add a statistics section in a new session in Creator Mode, and it will write that section from scratch. Well,
Speaker A
I probably won't do that right now, but it works. I tested it: it simply adds a new tab here or there—or wherever you ask—or maybe some buttons with hints that appear after your agent's response , so you can click here and immediately
Speaker A
continue, sending that prompt to the chat context so the agent can react to it. That's what customization is all about. Now, we've basically looked at the Deep PsyCap agent as, well, a classic agent, one that most of us have
Speaker A
used in one way or another. It's like a coworking space, codexes, and so on.
Speaker A
That's how you use it in this format. And it's interesting, yes, indeed, there are a lot of possibilities, and you can customize everything. So, it's like Linux in the agent world, where code is MacOS. That's how I think it
Speaker A
can be presented. Now, let's move on to the web version of Deep Harness to draw that analogy I mentioned at the beginning. Here's our Deep Harness web interface. And what is that analogy?
Speaker A
The analogy is as follows. As you can see, this is the interface for managing the agent on our computer, in this case , which is in the web version. Let me remind you that Deep Harness launched its web version first, and the desktop
Speaker A
app only appeared some time later. Why am I saying all this? The web version essentially works like this. We launch a server that, uh, provides this panel for interacting with the agent. And this server runs on our computer and
Speaker A
performs all the actions. Now let's think about where else these web servers are used. Well, in web applications, of course. If you've ever created some kind of SAS or some other application and implemented an agent, if you've delved even a little into the
Speaker A
code or even into the logic of how it works, then you understand that in order to create an agent in your application that your users will use— well, not you, not just you, at least, but so that different users can use
Speaker A
your AI agent, which edits things, does things—you need to write everything from scratch, because MK just returns text based on the description. So how is this usually done? We write a request, send some prompt to the lab using a description, get a response,
Speaker A
then look at that response, parse it somehow, or something else. Basically, then we do something with it. That is, we can ask the neural network to use certain tools that we describe in the format, or something else. After that,
Speaker A
when we receive a response, we have to run all these processes ourselves, some changes there, I don't know, files, additional requests, whatever. And Deepsicha can fit perfectly into this process. And in my opinion, this is exactly the point that most reviews
Speaker A
about Deepsic Harness miss when they talk about the web version only, because in this context, Deepsic Harness becomes not just a configurable agent that you can use on your computer . It becomes an engine and an agent that can run in your application. And
Speaker A
that's really cool. And in Deeps Harness, well, let's remember, yes, it's a construction kit where you can assemble any configuration and agent, like from blocks and plugins. But now imagine that you can cram all this into your own SAS product. What
Speaker A
opportunities does this open up for you to implement in your project? Well, I think you understand, the possibilities are vast. Obviously, this could have been done without DPC Harness, but with DC Harness it's simply much more convenient, because, in my opinion,
Speaker A
it's perfectly tailored for this. I don't know what deepsk's original positioning for this hardware was, but for some reason, it seems to me that this is primarily for this purpose. If we look at the documentation for the psyk, there's not a word about a web
Speaker A
interface or a desktop. There's only Webi here for now. Yes, only one page is dedicated, and that's just the basic information. It's a link to Redmi on GitHub. The Development section is a whole section, dedicated to development , plugin creation, and general
Speaker A
configuration of this and the agent. Obviously, plugins are used in both the desktop and web versions, and, well, everything is built on plugins. And overall, this probably makes sense.
Speaker A
Regardless of where the focus is— whether on personal use or embedding in apps—everything is still done through plugins, and it's logical to describe how to work with them. Nevertheless, I think this is also a specific indicator , because, well, some agents were
Speaker A
primarily deployed there—not a desktop app, not a terminal app, not a terminal app (like the original Claude code in the terminal), but a desktop app. Well, the desktop app looks a lot like a CAc product. I don't know, maybe
Speaker A
this is some conspiracy theory-level idea that popped into my head, but for some reason it seems exactly like that: that DBC Carn is ideal for embedding into certain applications, and that's probably what it was designed for. Okay , that's exactly what I wanted to say,
Speaker A
and in my opinion, it's perfect. I tested and created an example of such an app, which I'll show you a little later. This demo app, which has Deepsic Carn under the hood, works perfectly.
Speaker A
It works with this app's data as a built-in agent. It's really cool and quite easy to do. I'll leave the demonstration of this app for last, so you'll have motivation to go through the last theoretical section of this
Speaker A
video. And in this theoretical section, I want to talk about how Deepsic works internally. That is, it consists of plugins. Let's dig a little deeper, without any code, but at least use a diagram to understand how it works. The
Speaker A
first level worth paying attention to is the plugin. Well, we've already looked at plugins. It's more or less clear what they are. In the simplest case, a plugin can literally be a single file with code. Then we just
Speaker A
need to specify the path to this plugin in the config file to enable it. And that's basically it, the plugin is ready. Of course, in more complex cases , there will be more than one file, but nevertheless, it's simply code that
Speaker A
provides Agentusik with certain tools and capabilities for Harness. The plugin can be linked to certain events and perform certain actions. Basically, anything you want can be done through a plugin. When we create a tool through a plugin, we essentially remember in the
Speaker A
request to the neural network that we're working with text. The text goes into the neural network, your plugin appears in the list of tools, and the neural network can call it. This way, you can create your own tool that
Speaker A
Neronka will call, for example, to query your database or reports. Remember, it doesn't necessarily have to be running on your computer. It could be running your CAS product and agent. So, Neronka sees the tools, looks at user statistics, user
Speaker A
information, and some user data, calls the corresponding tools, and edits them . And all these capabilities, all these tools, can be provided via a plugin.
Speaker A
You can create slash commands, UI components (we've basically covered all of this), add certain pieces to the prompt sent to Neronka, connect additional services, process certain events, intervene before a certain step , approve it, make adjustments, or prohibit it. Well, we've talked about
Speaker A
plugins. This is the basic building block of our construction kit. Plugins are then packaged into a bundle—these are the building blocks plus instructions on how to use them. So, essentially, it's a plugin package. A bundle may contain its own
Speaker A
configuration file, for example, the one we looked at. This is Cordis patch yam. It may contain, say, the following instructions: Enable the built-in MCP server, add review mode. By the way, the "W" mode we created should have appeared in this file. It may disable
Speaker A
an interface, for example, if it was created for our web or desktop profile, enable the built-in codec subagent.
Speaker A
Well, in the bundle, you can specify some adjustments to our agent settings in the config. Let's move on. Bundles are stored in a profile. A profile is exactly what we saw for web and desktop . So, in the profile, we already have a
Speaker A
list of bundles in order. And given that each bundle can have its own config, the order matters. For example, let's look at the web profile. This is the profile that opens the web interface for interacting with the dipstick harness. It has the following
Speaker A
bundles. First up is DSH Base, which is the core engine, the log, the agent cycle, the sandbox—basically, everything the agent needs to function.
Speaker A
Next comes DSH Web App, which is the web server UI interface through which we interact with DeepSic Harness. Next come our bundles, if we want to add them. And after that comes Cordis Patch Yamal—that's the config we edited,
Speaker A
where we can make fine-grained edits on top of all the configs that came before . What I want to highlight here is that DSH WebU App, in this case, is the UI interface we interact with, but it's interchangeable. So, these interfaces
Speaker A
on top of DSH Base are different. This is DSH webUP, which is what we were talking about. DSH Headless is a single task that runs from the command line.
Speaker A
So, if we want to use the Deepsic harness from the command line, then we use DSH Headless. If we want to use it in a CA product, well, in some application of this agent, then the DSH SDK App Bundle will suit us. In this
Speaker A
case, the agent will be controlled by our code. And this is really cool, in my opinion. That is, for implementing agents in my projects, this is absolutely top-notch. Today we saw two such profiles: web and desktop. But you
Speaker A
can create your own such profiles, you can create them from scratch or based on an existing profile. For this, the following commands are used. Well, you probably don't need to remember them.
Speaker A
Google them or ask your agent. That is, we write which profile we want to inherit our new one from. Well, then we select web, Headless, SDK, SDK, minimal , ASP. Here in the table there is, uh, a list of profiles and the bundles it
Speaker A
is compiled from. Well, the main thing to remember here is probably the principle itself: we can either inherit our own profile from an existing one or create one from scratch. To do this, use the following command. We create a
Speaker A
My Agent profile and add a bundle to it . That is, what bundle it will consist of. Well, then we can edit it, add new bundles, and so on. After launching Deepsic Harness with the web profile, we launch the Deepsicхаes process,
Speaker A
which runs process-level plugins. These are the basic ones. Well, with the web profile, we launch the Deepsek harness process with this bundle configuration, which, in turn, consists of plugins, containing plugins. That's it. I also promised to explain at the end what PTS
Speaker A
is, this mode. Actually, I probably could have said it earlier; I shouldn't have put it off. So, to understand this mode, I'll draw an analogy. In normal mode, we send the model a prompt with information about all the tools. If the
Speaker A
model decides to call a tool, or several at once, it responds with text —roughly speaking, text that says, " Call this or that tool." Then we call that tool and send the same input to the model again, essentially the entire
Speaker A
chat history, information about the tools, and the result of calling that tool. Well, basically, we talked about this at the beginning. Here's the diagram. The difference between standard mode and, perhaps, PTK—it's probably clear, because Programming Tooling, I think, is what it's called.
Speaker A
Basically, in PTK mode, the model, instead of writing a list of tools to call, writes code within which all the tools can be called. It can write quite a bit of code, or, well, a short one.
Speaker A
Then this code is run, and after that, only the result of executing this code is sent to the model. That is, the data volume may be smaller than in standard mode. Instead of sending all the tool results, we send only the code
Speaker A
execution result. It may be smaller. But, by the way, this is not true for all tasks. Sometimes it's easier to call specific tools. Well, basically, that's the only difference. We've already talked about the other modes, basically. The only thing is, I forgot
Speaker A
to show you this table. Okay, I'll show you now. We won't dwell on this for too long. And anyway, we can probably finish up and show you the demo project . This is what the project looks like.
Speaker A
Here we display statistics for some CAC product. And the statistics are all great and cool, but in addition to the statistics graphs, we also have a window for working with the Agent. And this is what we're primarily interested
Speaker A
in. Here are some prompts for an example. Let's try executing one. That is, what the Rp was at the end of 2026.
Speaker A
So, we have a request and, uh, our agent thinks, and here is the result.
Speaker A
OurAgent was launched within the code. So, it's a simple function, essentially , just a function in the code that launches this agent based on the DeepSicx harness. And it has the tools it needs to view data from the database
Speaker A
, tools for creating graphs and tables. So, it's 100%customizable to your needs . It's not just a text response like you would get if you sent a request to Llemka. Well, in the best case, it would tell you what queries to make to
Speaker A
the database. You would make them. After that, you would have to send them all and write it all by hand from scratch. But here, the DeepSicx harness is launched under the hood in the code, which has tools for getting data,
Speaker A
drawing a graph, performing some analysis, performing some actions with the data—basically, everything you want. And it produces data. It also says what the response is based on.
Speaker A
There are some metrics there. Okay, that's a flaw; more information could have been provided here. The point is that he connected to the database, analyzed it, and used tools to create some graphs. And all of this is based
Speaker A
on Deeps harness, which is extremely convenient and simple, much easier than writing it from scratch. So, this is harness. Here it is, here it is. This is harness. So, normally, you would have to write this harness from scratch
Speaker A
. Here you use psycharness. Well, I think you get it. I hope I'm explaining it. Basically, this is harness. This is the harness to which we harness our horse, our ELL, and then we plow the land on this or that. This is super
Speaker A
cool. Let's try, I don't know, sending some other query there. Let's say, why did our churn increase in August on the Starter plan. The agent is currently analyzing our data, but while it's doing that, I'll just show you that in
Speaker A
the database created for this project, we store information about recent cancellations. There's a tariff, a starter tariff somewhere, a pro tariff somewhere, and there's a reason. Like, users wrote in their feedback: "Too expensive, went to the contractor, too
Speaker A
expensive," and so on. So, it's analyzed all these requests and responded with reasons, or rather, hypotheses, why we, uh, could have had churn on the starter tariff. And it says it's mainly caused by the price increase from 990 to 1,490. And it's
Speaker A
provided some additional information here, and written up verified hypotheses. Anyway, that's not important right now. What's important is that it's DPC Carness under the hood , equipped with plugins that provide the relevant neural network tools. It accesses our database, checks the data,
Speaker A
analyzes it, generates graphs for us, and it's super convenient. And in my opinion, this is the very aspect of DeepSeek Harness that is greatly underestimated in many reviews, and even more so, overlooked, which no one talks about. Okay, I think there was a
Speaker A
lot of information in this video. Let's sum it up. Is it cool? Of course, yes.
Speaker A
Does everyone need DeepSeek Harness? I don't think so. Does it kill code or codex? I don't think so. They're like two different categories. There's MacOS , and there's Linux. If you want to customize everything to your liking, okay, it might be useful. If you just
Speaker A
want to enjoy working with eAgent and not have to worry about anything, just enable it so it works, it's better to download the code. But you also have to understand that if you want to set up a server, well, let's say, yes, you won't
Speaker A
be installing MacOS on it, you'll be installing Linux on it. The same thing here. Moreover, in addition to the standard agent we use with our own computer, Deeps offers the ability to embed the agent in your own applications and services. And this is
Speaker A
where it's much more powerful than Claude or Codex. Well, in my opinion, because, yes, Claude and Codex also have their own tools, their own SDKs, but Deeps Harness is much more flexible and customizable in this regard. And, in my opinion, it's a much better
Speaker A
solution if you embed the agent in your project. And it's a fantastic application. As for personal agents, desktop, I don't know, a web version for yourself. Well, if you need all this customization, if you want to delve into it and configure everything,
Speaker A
then yes, other agents don't offer such capabilities. At least, I haven't heard of any. Perhaps something exists. At the moment, DPC Harness is the only one I know of in this category of agents.
Speaker A
Basically, I think we can wrap things up here. In this video, we didn't look at the code under the hood, simply because I think most of my audience doesn't really mess with code. Just in case, if you need to tweak something in
Speaker A
the code, you can simply use your own agent, send him the Harness DPC documentation, and ask him to change anything there if you need it. The same applies when developing and creating an agent within your application. Send him
Speaker A
the Harness DPC documentation and tell him what you need. Basically, it works. That is, the application I showed you, the demo version of this application, it's put together roughly like this. Of course, I dug into the code there; I
Speaker A
was interested in seeing how it all works. But it was all created simply with Claude's help. I sent him the documentation and asked him to do it.
Speaker A
He did it, and then I looked at it. Well, it all works, everything is great . If you really need an in-depth analysis of the code, let me know. I'm just not sure it's necessary. And I don't think everyone would be
Speaker A
interested in it. But if you need it, let me know, maybe I'll do it. If you have any questions, leave them in the comments. Either I or someone else in the audience will answer them. If you enjoyed this video, give it a like so
Speaker A
YouTube can recommend more useful content to you. Subscribe to the Telegram channel "Gonyi Wipecoding." There I publish useful materials on vibecoding, neural networks, and agents . Subscribe to the YouTube channel so you don't miss new videos. And with
Speaker A
that, I say goodbye to you. Happy coding, everyone, and see you soon.
Topics:Deep HarnessAI agentslanguage modelsopen sourcepluginscustomizationClaude CodeDeep Learningagent frameworkNeural networks
