YT YouTube2Text

YouTube2Text → Transcripts → DeepSeek Harness - НЕ убийца Claude Code. Все поняли его неправильно

DeepSeek Harness - НЕ убийца Claude Code. Все поняли его неправильно — Transcript

by Alexey Andreevsky · 10,561 words · 1,582 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

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

About this transcript

This page contains the full transcript of DeepSeek Harness - НЕ убийца Claude Code. Все поняли его неправильно by Alexey Andreevsky, generated from the public captions YouTube serves with the video. The transcript has 10,561 words across 1,582 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.