El Juez

Six critics, six directions, one answer. El Profesor credits durable execution and verification placed "at any node as ordinary code", El Hacker writes his own checkpointer against his own Postgres, El Amigo cares that a run resumes on Wednesday. Nobody found a dealbreaker.

What the agreement costs is plumbing, and El Crítico prices it: local models arrive through ChatOllama and MCP through langchain[mcp], so "the dependency you were told you did not need is the one that ships the tools". La Jefa is overruled on the library, since her $39 a seat is the hosted platform. Adopt, pinning LangGraph and LangChain as one release.

The panel agrees within 1.25 points and El Crítico sits at the bottom of it. He says the loop runs in your process with no isolation layer, so whatever credentials that process holds, the agent holds. El Hacker scores highest for the same architecture: Ollama first-class, MCP in both directions.

El Hacker wins on the design and El Crítico is overruled on the score, not on the remedy: in-process is why it debugs well. La Jefa's plain approval stands, since there is no seat to buy. Adopt with conditions: agent workloads under a separate scoped identity, and La Inversora's migration plan written before the second service depends on it.

El Profesor holds the low mark at 6.25 and his complaint is absence, not fault: no benchmark is published for the CLI as a scaffold. El Hacker, usually the floor for such a tool, reaches 5.75 because Apache-2.0 lets him fork it and --oss invites his box. His grudge is tuning, not access.

El Profesor is right and is answering a question the reader did not ask; a missing number is not a defect. El Crítico's warning about sandbox_mode chosen once and forgotten is a setting, not a dealbreaker. Adopt, if you already pay for ChatGPT; if you pay by token instead, cap the spend the day you install it.

El Amigo, El Profesor and El Hacker praise three different layers: who else can edit it, workflows published as OpenAPI endpoints, and one docker compose pointed at a local endpoint. Nobody found a dealbreaker, and the low score is 7.25.

What that agreement costs is the question none of them scored: El Crítico's, that a graph edited by dragging never appears in a pull request, so the review culture around it has to be invented. He is right and he overrules nobody, because the answer is a process rather than a product. Adopt, self-hosted with one named owner, and settle who reviews a prompt change before a non-engineer makes one.

Three quarters of a point separates the whole panel, the narrowest spread here. The one dissent is El Crítico's, and it is about gravity rather than quality: Gemini is the default, the sample hard-codes gemini-flash-latest, and everything else arrives through a LiteLLM adapter. La Inversora agrees from the other side, the free SDK starts a meter on Google Cloud.

The agreement costs the reader the question nobody asked: this is a good framework and a distribution channel. El Crítico's warning wins as a test, not as an objection, and La Inversora's hedge is the order. Adopt, and keep the agent definitions portable so a Gemini default never becomes a dependency.

The spread is a single point, the narrowest kind, so the question is what the agreement costs. El Crítico names half of it: the model "can be replaced through a custom provider. The tools cannot." La Jefa names the other half, tracing that lands on the vendor's platform by default.

El Hacker scores it highest and calls it the vendor SDK easiest to leave; he is measuring the loop, which he can fork, not the hosted hands, which he cannot. He is overruled on portability. Adopt with conditions: local function tools for anything touching your data, and tracing disabled until security has read the retention terms.

El Hacker gives this a 9 and La Jefa a 6.5 over the same editor. He calls it the only tool here he would call both fast and mine: GPL-3.0, MCP in settings.json, Ollama on his own hardware. La Jefa reads one line on the pricing page: SSO, SAML and SCIM planned, not available.

For an individual El Hacker wins outright and La Jefa is overruled. For sixty seats she wins and he is overruled; her sentence ends the meeting. El Crítico's default binds both: sandboxing is opt-in and fetch sits outside it. Adopt with conditions: sandboxing on before the first session, and no team rollout until SAML ships.

El Hacker sits at five and La Inversora at eight and a half, and it is one fact read twice. He sees a closed tool where nothing survives the vendor. She sees the vendor that trains the model shipping the agent, which no one can acquire away from you.

For anyone already paying the model bill, La Inversora wins and El Hacker is overruled: the fork he wants was never on offer. The binding objection is El Crítico's, that the Bash sandbox is off until you run /sandbox. Adopt with conditions, the condition being the sandbox on and a monthly usage report from day one.

The panel agrees within a point and a half. El Hacker gets a copyleft licence, his own endpoint and a protocol server. La Jefa gets isolation, a governance layer and something that runs on her infrastructure. La Inversora likes the open-core split. Nobody found a dealbreaker.

What the agreement costs the reader is El Crítico's point, and it is a real one: adopting this means operating a platform, with the headcount that implies. He is not overruled, he is the price of the agreement. Adopt, provided you have a platform team, and if you do not, La Inversora's alternative reading applies: buy the hosted thing instead.

The spread is 4.5 points, the widest here. La Inversora scores it near the ceiling because incumbency is the moat and the invoice was approved years ago. El Hacker scores longevity at two, nothing forks if Microsoft loses interest. El Crítico names the fact between them, the local agent mode runs without isolation and the isolated one is metered.

La Jefa wins, on El Crítico's fact rather than La Inversora's thesis: the safe path is the cloud agent, and the cloud agent is the metered one. El Hacker is overruled for any team already on GitHub. Adopt with conditions, an organisation-level cap on premium requests and a monthly spend report.

Agreement, and it is the finding. La Inversora scores it highest on two hundred thousand stars and switching cost measured in workflows already built; La Jefa on a price that does not multiply by headcount. Nobody found a dealbreaker.

Two things the enthusiasm hides. El Hacker is precise where the marketing is not: a Sustainable Use Licence is fair-code, not open source. El Crítico is right that an agent node breaks an engine built for repeatable steps, and approval "does not scale to a workflow firing hourly"; he is overruled on the score, not the warning. Adopt, self-hosted first, alerting on the agent node's output shape.

Nobody disputes the loop; the three-point split is about keys. El Hacker runs it already: one JSON document with a published $schema, Ollama when offline, and a fork that already exists. La Jefa counts the same freedom as sixty spend lines with no audit log behind them.

La Jefa wins at team scale and her own remedy is the ruling; El Hacker is overruled only on distribution, since a fork that survives its vendor does not survive procurement. Adopt with conditions: centrally issued keys that can be revoked, a spend cap, and one config file checked into the repo.

El Hacker scores the provider list and the protocol support; La Jefa scores a documented unattended mode with real exit codes and a continuous integration recipe. The agreement is that this was built by someone who expected it to be automated rather than demonstrated. El Crítico is the only dissent and his objection is narrow.

He is right and he is not overruled: how you install this changes what you get, and that is a genuine trap. It is also a condition rather than a verdict. Adopt, installing from the published package rather than from source unless you intend to build the helper binaries yourself and know why.

La Inversora scores it highest on the rename: the product is the loop, not the CLI. El Hacker scores it 5.25 for the opposite reason: MIT on paper, Anthropic Commercial Terms in practice, a bundled binary he cannot read. El Crítico states the fact under both, Claude only and no model of your own.

El Hacker is overruled: a library that ships Anthropic's own loop was never going to hand him the model choice. La Jefa wins, because it rides the Bedrock or Vertex contract already signed. Adopt with conditions, the condition being API credentials rather than a consumer subscription, and the branding rules read before you ship.

Agreement is the story. El Hacker likes the licence and the model freedom, El Profesor likes the context handling, La Inversora likes the distribution, and none of them found a dealbreaker. La Jefa scores lowest, and she is answering a question this row never posed: nothing here was offered as a product she administers.

El Crítico is the one to read twice. His point is not that the design is wrong but that a configurable boundary is an unconfigured boundary until somebody sets it. Adopt, if you are building the agent rather than buying one, and pick the shell backend before the first command runs.

El Crítico says a flow is "a serialised graph" that "does not diff into anything a reviewer can reason about". El Hacker scores it highest for MIT, one docker run and MCP in both directions. La Jefa supplies the deciding fact: it does not run unattended, so no pipeline ever gates a flow.

On his own machine El Hacker is right. Where a customer is downstream he is overruled, because eyeballing a picture is not a control and El Crítico's objection becomes the release process. Adopt with conditions, the condition being prototypes and internal tools only, nothing customer-facing until a flow can be tested in CI.

The split is three and a half points wide. El Hacker gets an mcp.servers toolFilter and llama.cpp on his own box; La Jefa gets sixty daemons, no vendor to answer a questionnaire, and a state ban her security team finds in ten minutes. El Crítico supplies the fact under both: the sandbox mode ships off.

For one machine El Hacker wins; La Jefa is answering a question he did not ask, since there is nothing here to procure. She is overruled for the individual and right about the fleet. Adopt with conditions: sandbox mode set before the first run, and the repository kept out of a bind mount.

The split is 3.25 points. El Hacker scores it highest, MIT, any OpenAI-compatible endpoint, and nothing that needs the Portal. La Jefa scores it lowest because the gateway puts an agent inside company Slack and the cron runs unattended overnight. El Crítico names the mechanism both are describing, a toolset in month three that nobody reviewed.

El Hacker wins for the individual and La Jefa is right that this cannot enter a company as it stands; she is not overruled, only early. El Crítico sets the condition. Adopt with conditions, the skills directory pinned in git and read weekly, and execution on one of El Profesor's isolated backends.

El Hacker gives it a nine for prompts in the repository and a model flag that runs air-gapped. La Inversora gives it a five and a quarter because there is no business model. They are not scoring the same object: his is a program, hers is a vendor, and Apache-2.0 means the reader only takes delivery of the first.

La Inversora is overruled. El Profesor and El Crítico between them describe why: the most legible architecture on the board, and auto-commit as the mitigation for edits that land on your disk directly. Adopt, for the engineer who reads the diff before the commit lands.

El Hacker scores it a nine and calls it the full stack he owns; La Jefa sits three points lower on the same facts, because the free path is sixty personal keys with no central audit log. El Crítico's objection applies to both: "the meter, and it is your meter."

Both are right about different buyers, so the tiebreak is El Profesor: the leaderboard entry is maintainer-checked, which no rival here can say. El Hacker is overruled on cost, not on ownership. Adopt with conditions: a spend limit in the provider console before the first run, and the Enterprise quote in hand before the sixtieth seat.

El Hacker wants a proxy that takes any endpoint he names and answers to a config file he owns. El Crítico stops at capability fusion: a model without native vision or tool support is presented as though it had them, and the agent upstream is never told. Both read the same README.

El Crítico wins on the technical point and El Hacker is overruled on defaults, not on ownership. La Inversora's reading, that this exists because prices differ, sets everyone's time horizon. Adopt with conditions: route only to models whose native capabilities match the task, and read the request log before trusting a fallback.

El Hacker scores it highest because the extension API is the product. El Crítico scores the same API lower: extensions are modules loaded into the process holding your keys, with only trust around them. La Jefa refuses because /login signs sixty engineers into personal subscriptions from a work terminal.

La Jefa is answering a question about licences, not about the tool, and her objection has a remedy she names herself. El Crítico's does too: keep the extension list short. El Hacker wins on the harness and is overruled on the registry he admits is missing. Adopt with conditions: company-issued keys, and no extension you have not read.

The panel agrees, and it agrees high: nobody scores it below 7.5. El Profesor likes the doubled verification, La Jefa likes OTLP into a backend she already funds, El Hacker likes the offline test model. The dissent is El Crítico: the coding agent and memory live in a second package.

What the agreement costs is a narrowing: this is a library for typed Python, and outside that language it is not a candidate. El Crítico's seam is real and it is an afternoon, not a dealbreaker; he is overruled. Adopt, with the core and the harness pinned together and one named owner for upgrades.

La Inversora reads the ownership as the reason this will keep shipping and also as the reason it will always tilt toward one model family. El Hacker reads the same licence and endpoint support as an exit he can take whenever he likes. They are pricing lock-in from opposite directions and arriving at the same three years of commits.

El Hacker wins, because a permissive licence and an open endpoint make La Inversora's tilt a preference rather than a trap, and El Profesor's caution about self-published evaluation is the only thing left to guard against. Adopt, and treat the vendor's own benchmark as a starting point rather than a result.

El Hacker scores this at the ceiling because the licence is open, the prompts are editable and the weights can be his. La Jefa scores reliability at 5 because there is no supplier to call and nothing runs without a person present. La Inversora settles the argument neither of them framed properly: foundation stewardship removes the acquisition risk that ends most tools on this board.

El Hacker wins, and La Jefa is overruled on the specific claim that a foundation is worse than a startup, because it is measurably better on the axis she cares most about. El Crítico's registry warning is real and small. Adopt, and check that the extensions your team relies on exist in the open registry first.

Agreement, 1.75 points wide: El Hacker at 7.75 for MIT and Playwright underneath, La Inversora at 7.25 for a margin that moved from renting Chrome to selling inference. What the agreement costs is El Crítico's sentence: the README invites you to reuse your Chrome profile with saved logins.

El Crítico is not dissenting, he is pricing the default, and the default is the ruling: a prompt injection on any page runs with your sessions. El Profesor is overruled on the numbers: a self-reported 87.4% decides nothing here. Adopt with conditions, the condition being a throwaway browser profile with no saved logins in it.

El Hacker gives it a nine because Apache-2.0 means readable prompts and his own endpoint as a provider. La Jefa gives 5.75 for the same reason: the free path is sixty engineers with sixty keys, no SSO and no audit log, and the Enterprise tier that fixes that is custom-priced.

One developer buys ownership; sixty buy an unmanaged fleet. La Jefa's reading wins at team scale and El Hacker is overruled there, though he is right about his own machine. El Crítico's fatigue point survives both: the autoApprove list ships with the product. Adopt with conditions, the conditions being an Enterprise quote in writing and auto-approve disabled by policy.

The spread is three and three quarters. El Hacker calls it VS Code with the source taken away, and keeps it installed for Tab. La Inversora calls the editor the place a developer lives and the habit the moat. El Profesor notes what neither prices: no published number at all.

La Inversora wins for anyone who ships from an editor, and El Hacker is overruled by his own last line, that the tools he owns are slower. El Crítico names the condition: Run Everything hands the agent your machine and your credentials. Adopt with conditions, auto-run policy set centrally and a monthly Cloud Agent spend cap before rollout.

The split is four points. El Hacker scores it near the ceiling: Apache-2.0 Rust, extensions as MCP servers in a file he keeps in git, Ollama on his own box. La Inversora scores lowest because there is no cap table and nothing to acquire. El Crítico supplies the condition, sandbox mode is an option rather than a default.

El Hacker wins, and La Inversora is overruled on the point that matters to a reader: a foundation with no revenue is the safest counterparty here, not the riskiest. Adopt with conditions, sandbox mode required by policy as La Jefa asks, and one named internal maintainer, because there is no external one.

El Hacker scores it highest for Apache-2.0, a versioned TOML config, MCP entries and ACP mounting. El Crítico read a different page: programmatic mode "falls back to auto-approve when --agent is not provided", and admin-managed config is "a distribution mechanism, not a security control". El Profesor scores lowest because 72.2% belongs to Devstral 2, not to the harness.

El Hacker's reading wins, since the configurability he scores is what fixes El Crítico's default. El Profesor is overruled on the score, not the point: the number matters when quoted, not when used. Adopt with conditions, the condition being --agent pinned in every scripted invocation before one reaches CI.

La Jefa's requirement is that code and prompts never leave her network, and few products are designed for exactly that. El Hacker arrives at a similar number by a different route: the client is closed, but the model weights are published under open licences, an inversion he did not expect. They agree, and the agreement is the finding.

El Crítico's dissent survives both: isolation depends on a container engine and a proxy enforcing network policy, so it is a configuration, not a guarantee. He is not overruled, he is scoped. Adopt with conditions: self-managed deployment, network policy set explicitly, and the sales conversation before any rollout.

The agreement is the interesting part. El Hacker likes the licence and the local endpoints; La Jefa likes the restrictions she can set per mode and per path; La Inversora likes that the revenue line exists without a subscription attached. Three different questions, three compatible answers.

El Crítico is the lone dissent and his objection is real: the guard that permits longer unattended runs is a list of things to refuse, and lists are never finished. He does not overturn the panel, he scopes it. Adopt, and keep the autonomous runs inside a checkout you would be willing to delete.

Six critics arrived at similar numbers from different directions. El Hacker gets a permissive licence, local inference and a tool-protocol client. El Profesor gets an explicit context model. La Jefa gets a way to reuse a subscription the company already buys. Nobody found a dealbreaker.

That leaves La Inversora's objection, which is not about the software: one maintainer carries all of it. She is not overruled, she is priced in, because the licence outlives the maintainer and the code is Lua a team can read. El Crítico's surface-area warning is the caveat, not a condition. Adopt, if you use this editor and pin the revision you deploy.

The panel agrees within a point and a half, La Jefa at 6.00 to El Hacker at 7.50. La Inversora is the one grading something else: a 45-day onboarding and forward-deployed engineers sold a la carte, which makes the library the lead generator and the engineers the product.

She is right about the company and it does not touch the library, which is MIT and installs like any Python package. La Jefa's line holds against the hosted tier, and El Crítico supplies the daily risk, that role, goal and backstory are strings. Adopt with conditions, the library only, evals written before crews and the model version frozen.

La Jefa likes this for a reason that has nothing to do with the agent: it ships inside a product her company already licenses, so adoption is a memo rather than a purchase. El Crítico reads the tools page and finds that the built-in shell executes in the user's own environment, whatever the branding implies. He is noting an inference buyers make unprompted.

La Jefa wins on adoption and El Crítico on configuration, so neither is overruled. El Hacker's declarative file is what makes his condition enforceable. Adopt with conditions: the shell toolset is disabled by policy, or the agent runs somewhere you are willing to lose.

The panel agrees to within 1.25 points, and El Hacker joins it: BYOK reaches Ollama and LM Studio with no subscription, which he calls more than most IDE vendors allow. La Inversora scores highest, on pricing that needs no sales team. El Crítico's dissent is one checkbox, brave mode runs shell commands without confirmation.

El Crítico is right, and describing an opt-in setting rather than a default, so it conditions the configuration and not the purchase. La Jefa's approved wins. El Amigo's credit anxiety is a budgeting problem, not an objection. Adopt, if the IDE is already on the invoice, with brave mode off in repositories with deploy scripts.

Agreement this broad on a library this large is the finding. El Hacker scores it highest on MIT and 24,000 forks: "whether it survives the company was answered years ago". El Crítico's complaint is the three-layer dependency matrix, a pinning discipline, not a dealbreaker. El Profesor notes nothing is verified by default.

La Jefa is the apparent dissent, and she is not talking about the library: $39 a seat, Google and GitHub login rather than SAML, traces carrying prompts. She is overruled on the library and correct on the platform, which is a separate purchase. Adopt the library now, and let LangSmith wait on the retention review she named.

El Hacker scores it three points above La Jefa. El Crítico argues the daemon runs without container isolation. The row disagrees: it records macOS Seatbelt and a Docker or Podman sandbox with a published image. The row wins, and El Crítico is corrected on the fact, not on the habit.

That leaves La Jefa's objection, which is the real one: the Coding Plan means choosing a Beijing or an international endpoint, and sixty laptops on the wrong one is a finding. She wins over El Hacker, who is overruled on residency. Adopt with conditions: the endpoint chosen by security first, and a sandbox mode enabled before daemon mode.

The panel sits within two points and agrees on the design. La Jefa gives it the rarest compliment here: monthly budgets per agent with hard stops, a finance report she can hand over. El Crítico prices the same mechanism, agents waking on heartbeats with no container under them, a loop that starts at 3 a.m.

La Jefa wins, because her remedy is the only one that survives sixty people. El Hacker's box in the closet is his own answer and is overruled as a company one. La Inversora's hosted tier is not shipped. Adopt with conditions: one shared instance, SSO behind a proxy, retention reviewed first.

El Hacker scores this highest and El Crítico lowest, and they are reading the same executor. He says "this one I own": Apache-2.0, weights on his own GPU, tools pulled from any MCP server. El Crítico says the sandbox is "one constructor argument away" and not on the default path, so generated Python runs where you are standing.

El Crítico wins, because a default nobody sets is the default that ships. El Hacker is overruled on the default, not on the license, and La Jefa's Hub concern rides with him. Adopt with conditions: a sandbox backend on every CodeAgent, and Hub publishing blocked at the org level.

The panel sits inside 1.25 points and El Crítico names the trap: the sandbox is a container in Warp's cloud while the local agent runs in your shell, and bring-your-own-key is gated to a $50 seat, so the safe setup is the expensive one. El Amigo is highest for one reason: no new window.

El Amigo wins for anyone who lives in a terminal and El Crítico is overruled on the score, not the configuration. El Profesor's footnote stands: 75.8 percent is best-of-k, so do not quote it bare. Adopt with conditions: Business or Enterprise so keys stay yours, plus La Jefa's spend cap and retention terms in writing.

El Profesor rates it high because the checks it runs are external to the model. El Hacker rates it high because the inference can be external to everyone. Those are two different arguments for the same property, which is that this thing does not require you to trust it. El Crítico's complaint is real and generic: the shell is the shell.

El Crítico is overruled on relevance rather than on facts, because he is pricing a risk that every plugin here carries and this one at least gates behind an IDE you already run. Adopt, and point it at a local runtime first so the first week costs nothing.

La Jefa scores it high because containment, cost tracking and fleet monitoring exist as product features rather than as intentions. El Crítico agrees the platform is serious and objects to one specific decision: encrypted credentials living inside a repository, where history is forever and rotation is nobody's job.

El Crítico wins on that point and loses the ruling, because a credential store is replaceable and the rest of this is not. La Jefa's reading governs for a team. Adopt with conditions: move secrets to a manager you already run before the second agent is created.

El Crítico's objection is the architecture itself. This drives a terminal emulator and reads a text interface back into messages, so an upstream cosmetic change becomes a silent data bug. El Profesor does not dispute the mechanism. He points at the shipped schema and the small four-endpoint surface, which turn that failure into a contract test rather than a mystery.

El Crítico is right about the mechanism and overruled on severity. La Inversora's reading of why Coder keeps this alive is the reason to expect it fixed quickly. Adopt with conditions: pin the version of the agent you wrap, and assert the message stream against the schema in CI.

La Jefa scores it high because it arrives inside a subscription her company already pays for and an administrator controls what it can reach. El Hacker scores it low because he cannot supply a key, read the source or move any of it elsewhere. Neither is wrong about the same product.

For a Salesforce shop La Jefa wins outright and El Hacker is overruled, because the switching cost he fears was paid years ago in a different contract. El Crítico's condition survives both: the highest autonomy mode bypasses the approval step. Adopt with conditions, the condition being that the bypass mode stays off org-wide.

El Hacker owns this outright: a permissive licence, local inference on his own hardware, and nothing that phones a vendor. La Jefa is not arguing with any of that; she is counting how many of sixty engineers use this editor, and the answer is small. They are pricing different populations.

For an individual in Neovim El Hacker wins and La Jefa is overruled, because a personal editor plugin is not a procurement item. El Crítico's caveat binds both readings: the interface tracks a commercial product's design, so upstream changes are cosmetic churn you inherit. Adopt with conditions, the condition being a pinned plugin revision.

El Profesor gives it the highest mark on the panel for telling you exactly where your credentials go and what it does before it goes there. El Crítico does not argue with that and points at what sits underneath: a front end is worth whatever the engine behind it is worth, and most of those engines are marked beta.

El Profesor wins for the reader who is already committed to one engine, and El Crítico is overruled for that reader only, because his risk lives entirely in the seven he would not have selected. Adopt, if you drive a single stable engine and leave the beta list alone.

There is no split. El Amigo, La Inversora and El Hacker arrive at the same place from three directions: per-user authentication, the switching cost it creates, and MIT packages in both registries. That agreement costs the reader the scrutiny: two unpriced risks were raised and neither moved a score.

El Crítico is right that one incident there is total loss of every connected capability at once, and El Profesor is right that first-stage retrieval recall across a thousand toolkits is unpublished. El Amigo's convenience case wins, bounded. Adopt with conditions, La Jefa's spend cap and one named owner of the meter before anything customer-facing depends on it.

El Profesor's case is architectural: agent output lands as commits on a branch, so review is an ordinary git operation instead of a screenshot. El Crítico does not argue with the design. He argues with its cadence, an experimental badge and no tagged release since August 2025 on a component whose job is containment.

El Profesor wins on whether to use the idea and El Crítico on how far to trust the implementation, so neither is overruled outright. La Jefa's condition follows from his. Adopt with conditions: pin the version you install, and treat it as a convenience boundary rather than a security one.

La Inversora reads the corporate news and marks the roadmap as somebody else's property now. El Hacker reads the licence file and shrugs: permissive terms and a public repository mean the code outlives whatever the company becomes. El Crítico argues about something else: how easily the permission gate switches off.

El Hacker wins for the individual and La Inversora is overruled for that reader only: an Apache-2.0 snapshot on your disk does not get acquired. For anyone planning a team's next two years she is right and he is overruled, because a fork nobody staffs is not a roadmap. Trial only, and re-decide when the next release cadence is visible.

El Hacker sits at 7.50, La Inversora at 5.75, and the disagreement is one clause. He calls the licence a fork with a waiting period, and says so while running it daily. La Inversora reads the same clause as deliberate: open enough for trust, closed enough to stop a hosted competitor.

La Inversora wins and El Hacker is overruled, because a delayed conversion is a schedule, not a trap, and he has already voted with his terminal. The live risk is El Crítico's: --yolo is a headless run holding your shell. Adopt with conditions, that flag off by policy and legal's read of the licence on file.

The split is the usual one and unusually wide here. La Jefa rates it high because the identity layer is already administered and the runners are already paid for. El Hacker rates it low because the source is closed and the freedom he wants is fenced behind one deployment shape. Neither disputes a fact. They are pricing a platform lock that one of them already accepted years ago.

For a shop running GitLab, La Jefa wins outright and El Hacker is overruled. For anyone else this row is not a purchase, it is a reason to switch code hosts, which is a larger decision than a review. Adopt with conditions, the condition being a credit ceiling set before the first flow.

El Profesor scores it lowest because "Kilo's design is inherited" and no benchmark is published for any surface. El Hacker scores it highest for that same lineage: two upstreams he already reads, and a fork that survives the vendor. El Crítico sits between them, calling each divergence "a Kilo-only bug that only Kilo can fix."

El Hacker's reading wins and El Profesor is overruled on the score, not the fact: inherited design is still readable design. The operative risk is La Jefa's, a gateway with sixty hands on it. Adopt with conditions, the condition being a capped gateway spend per team before rollout.

El Hacker scores it highest: Apache-2.0, a native sandbox, Ollama and LM Studio autodetected, MCP in both directions. La Inversora scores it lowest, "68,200 stars, no pricing page", and asks who pays the maintainers. El Crítico names the confusion between them, two codebases sharing one name after the Rust rewrite.

La Inversora is overruled, because there is no business model here to fail and the Python fork already proves a fork survives. La Jefa's not yet is right at sixty seats and beside the point at one, since there is no vendor to onboard. Adopt for the single machine running open models, pinning which of the two codebases you installed.

El Amigo scores reliability high because a stale anchor is rejected instead of applied, so the failure is loud rather than silent. El Crítico accepts that entirely and prices the other side: an edit format the model has to get exactly right converts a corruption risk into a progress risk, and a weaker model simply stops.

El Amigo wins, because a tool that refuses to do the wrong thing is the correct default and El Crítico's objection is a reason to pick a better model, not a reason to accept silent damage. Adopt, if you run it against a model strong enough to keep its anchors straight.

La Jefa scores this well because policy admission, approval steps, cost ceilings and redaction are all present without her platform team building them. El Crítico's objection is scale of a different kind: four transports, five chat channels and twelve runtime adapters is a surface no small project can keep uniformly good, and behaviour differs by backend.

La Jefa wins, because governance features that exist are worth more than adapters that are uneven, and the uneven ones can simply not be used. El Crítico is upheld as a scoping instruction. Adopt with conditions: pick one runtime adapter and one transport, and refuse the rest.

The spread is two and three quarters. El Hacker gets Apache-2.0 with a single carve-out that is labelled rather than hidden, and his own box as a provider. La Jefa gets sixty desktop installs, sixty sets of keys and no organisation tier.

El Hacker wins, since this was never a fleet purchase; La Jefa is upheld only in refusing to buy it at scale. El Crítico sets the daily condition, that with no terminal tool the agent never builds or tests what it writes. Adopt with conditions, one developer at a time, with a human build and test step before any generation counts as done.

El Amigo scores cost at the ceiling because there is nothing to pay and nothing to sign. La Inversora scores longevity low for the same reason, since a product with no revenue has not yet chosen how it will have some. El Crítico's dissent is about the approval model rather than the business model, and it is the only technical objection filed.

El Amigo wins for the individual, and La Inversora is not overruled so much as deferred, because her risk arrives later and his benefit arrives today. Adopt, on the condition that shell approval stays manual until El Crítico's concern has been tested on your own repository.

El Crítico marks it down because the model choice narrowed to one lab and the alternative harness is documented as deprecated. La Inversora marks it up for the same reason: the ownership question is settled and settled upward. El Hacker's 3 is consistent and irrelevant here, since nobody buys a governed cloud runner expecting to fork it.

La Inversora wins. A dependency you can name and a vendor you can invoice is what La Jefa is buying, and El Crítico's monoculture is the price of that clarity, not a defect hidden inside it. He is overruled on severity. El Hacker is overruled on relevance. Adopt, with a compute ceiling agreed before the first fleet runs.

El Hacker gives it 4.25: closed source, no key of his own, a binary CLI. La Jefa gives it 6.75 with SOC 2 Type II, CMEK and audit trails on every plan. El Crítico explains why the gap is not about taste, the meter is cost-plus with no bring-your-own-key.

El Hacker is overruled: ownership is not on offer at any price here. La Jefa wins, with El Amigo's line as the boundary, on a small repository you pay a markup for an index you do not need. Adopt with conditions, the condition being a codebase large enough that the Context Engine earns the 40 percent fee.

El Hacker scores the copyleft header and the scriptability, and grumbles that his models have no role here. La Jefa never gets that far: one supported operating system ends her rollout before the security review begins. El Crítico has a narrower worry about what the app may drive.

For a developer on a Mac, El Hacker's reading wins and La Jefa is overruled, because a free terminal is not a procurement event. For the fleet she is right and he is overruled, and no condition fixes an operating system. Adopt with conditions: individual installs only, and keep the embedded browser away from anything you would not paste in public.

The panel agrees inside a single point, 6.75 to 7.75. El Hacker, who usually supplies the dissent, ran it against his own backend with no account and nothing broke. The agreement costs the reader one thing: El Crítico's objection never moved a score, and it is that the protocol underneath has one implementer and one roadmap.

He is right, and answering a longevity question the reader is not asking this quarter. He is overruled on the score, not on the advice. Adopt, if your interface must show what the agent is doing, and treat the protocol as a vendor interface until a second implementation exists.

The split is two points and it is about the shell. El Hacker scores it highest: Apache-2.0 Rust, an install script he read first, OpenRouter with his own key. El Crítico scores the same integration as the hazard, a coding agent with command execution between you and every line you type. La Jefa adds that sixty engineers do not agree on one shell.

El Hacker wins on the tool and El Crítico wins on the install: read the setup step, then enjoy the binary. La Inversora's do not standardise is upheld against El Amigo. Adopt with conditions, individual opt-in and no production credentials on the machine.

El Profesor treats building the core tools into the binary as a deliberate architectural position and marks it up. El Crítico accepts the design and objects to what guards it, which is a list in a markdown file. Same decision, two different questions asked of it, and only one of them is about safety.

El Crítico wins on the guard and loses on the design, so neither reading is overturned. La Jefa's pipeline use is what makes the argument worth having at all. Adopt with conditions, the condition being that the per-agent allowlist is written before anything runs unattended.

El Profesor calls the methodology the cleanest here: "when the scaffold is this small, the score is the model's". El Hacker agrees from the other end, since "a fork is a copy". La Jefa calls it a research instrument and declines to roll one to sixty seats.

They win and she is overruled on the score, because she priced a fleet rollout nobody proposed, and her own condition names the right buyer anyway. El Crítico's finding is the live one: without an environment flag, every command lands on the host. Adopt with conditions, the conditions being the evaluation team only and a container policy written before the first run.

La Inversora scores this near the top because the distribution behind it is measured in millions of installs and owned by a company that is not going anywhere. El Hacker scores it low because none of that distribution is his to inspect. El Crítico is the one raising a fact both of them skipped: the long-running mode works across your tree with no containment recorded.

La Inversora wins on survival, which is the question most buyers actually have, and El Hacker is overruled for teams. El Crítico is upheld and becomes the condition rather than the verdict. Adopt with conditions: the delegated mode runs on a branch, never on the trunk checkout.

El Crítico and El Profesor are both right. El Profesor admires a control loop the user can see and interrupt; El Crítico notes that the editor around it starts from nothing, with no extension catalogue to inherit. La Jefa adds that the only documented install is a build from source.

The loop is the reason to look and the editor is the reason to wait, and for an editor the editor wins. El Profesor is overruled on priority, not on analysis. Trial only, and the exit criterion is a packaged release plus one week in which you never reach for the extension that is not there.

El Profesor scores the execution model highest of anyone here, because a run that can be replayed is a run that can be reasoned about. El Crítico does not disagree with the design. He says the guarantee is only as good as the component you configured underneath it, and that nothing in the library enforces that choice. La Jefa lands with him on operations.

El Crítico wins on where the risk lives, and El Profesor is overruled on scope rather than on architecture: he is grading the design, the reader is running the deployment. Adopt with conditions, the condition being a state store you already operate in production.

The panel is close and the one gap is precise. El Profesor rates the coordinator design highly because subagents return evidence rather than assertions. El Crítico rates it lower for a reason that has nothing to do with delegation: the containment is described and not specified, and confirmation is optional on a subset of calls. La Inversora adds the only other caution, and hers is about the author, not the code.

El Profesor wins on the architecture and El Crítico's caveat survives intact. Adopt, with confirmations turned on until you have read what the containment layer actually does.

El Amigo scores usefulness high because this puts agent behaviour inside the application a team already runs, with no second runtime to operate. El Crítico's objection is narrower than it sounds: the observability path leads to a third-party service, so the part you need most during an incident is the part you do not control.

El Amigo wins, and El Crítico is overruled on weight, because an optional integration is a default you can replace, not a dependency you inherit. Adopt, provided you decide what your own logging looks like before the first agent reaches production.

El Hacker and El Amigo value the Apache-2.0 visual bridge that syncs DOM changes back to real code. Conversely, La Jefa points out the absence of centralized governance, and El Crítico notes the restriction of routing exclusively through OpenRouter without local models. The panel agrees on the boundary: it only serves Next.js and TailwindCSS.

For a small frontend pair on that exact stack, El Amigo's view wins. For an organization needing fleet governance, La Jefa is right and the tool fails. Trial only, with the exit criterion being a successful sprint editing UI components without encountering OpenRouter configuration or workflow bottlenecks.

El Crítico is lowest with La Jefa and neither is arguing about capability. He says the product is an attacker by design and the no-false-positives claim arrives without a published rate. La Inversora is near the top: SOC 2 Type II, ISO 27001, and a reference list security buyers pay for before features.

La Inversora wins on the company and El Crítico is not overruled on the run: certifications do not authorise a target. El Profesor settles quality: the exploit executes, so a pass cannot be hallucinated. Adopt with conditions: a written target list signed by legal, staging first, and La Jefa's quoted number before any seat.

La Inversora and El Crítico are not arguing about the same object. She is grading the company and finds the strongest longevity story on the board; El Crítico is grading one flag and finds a review agent that also writes the fix. Both are correct and only one of them costs you anything this week.

El Crítico wins on operations and La Inversora is not overruled, since her point survives his: a well-backed tool with one dangerous default is still a well-backed tool. La Jefa's condition is the right one. Adopt with conditions, the condition being comments only, with the fix flag left off.

The panel is unusually close together here and the one dissent is El Crítico's. He is right that auto-approve turns the editor into something that writes files on an agent's word; La Jefa wants it deployed to sixty desks tomorrow because the rollout costs nothing. They are both describing the same speed.

La Jefa wins, and El Crítico writes the condition rather than losing the argument: an extension this cheap to install is also cheap to install with the wrong default. El Profesor's traffic log is what you use when it goes wrong. Adopt with conditions, the condition being one reviewed configuration for everybody.

Three points separate El Hacker, who scores it highest for MIT, one docker command and MCP at both ends, from La Jefa, who scores it lowest because a container with a full desktop per engineer is a compute line. El Crítico names the sharper problem: the rules the agent follows sit inside its own blast radius.

El Hacker wins, because the container answers El Crítico: the blast radius is a disposable image, not a laptop. La Jefa is overruled: her pipelines were never this tool's audience. Adopt with conditions, the condition being prompts and config in a volume you can throw away and rebuild.

Agreement, inside 1.25 points, and the cost hides in a line nobody scored. El Hacker rates it highest because the framework is Apache-2.0 and the agents come out as an MCP server. La Jefa prices the same product at $1,860 for sixty seats, plus $300 for SAML, with audit logs held back for Enterprise.

El Hacker wins on the half you install and is overruled on the half you buy: the control plane he can only rent is where La Jefa's numbers live, and hers are the numbers that decide. Adopt with conditions: AGNO_TELEMETRY=false on day one, and SAML and audit logs priced before the seat count moves.

El Hacker and La Jefa both score it well, which is the interesting part. He gets copyleft-free licensing and a provider list that reaches his own hardware; she gets an API she can automate against and a zero licence line. El Crítico dissents, and his complaint is breadth: one vendor maintaining that many integrations.

El Crítico is right and does not change the ruling, because his risk is slow and reversible while their benefits are immediate. He is overruled on timing, not on substance. Adopt with conditions: keep the approval prompts on, and re-check the provider you depend on after every release.

El Hacker scores this near the top of his range because it is open, it speaks the protocol in both directions, and the weights can sit on his machine. El Crítico scores lower for one structural reason: everything routes through a single background process, and a single process is a single failure. La Inversora is unbothered either way.

El Hacker wins and El Crítico is overruled on weight, not on fact. The process he distrusts is also what keeps four surfaces from disagreeing, and a restartable local service is a smaller risk than a vendor. Adopt, provided you can restart that service yourself and know how.

El Amigo scores the daily experience high because the work is visible while it happens. El Hacker scores it low because the source is closed and a key of his own is not accepted anywhere. They are not describing different software. They are pricing different exits.

For an engineer inside a company that already bought this, El Amigo's reading wins and El Hacker is overruled: the exit risk is the employer's problem, not the user's. For anyone choosing independently he is right and the ruling flips. La Jefa's seat ceiling decides the middle case. Trial only, one team, one quarter, exit if the sales conversation stalls.

La Jefa finds the controls her security review asks for and nobody else on this board ships. El Hacker finds the same controls and calls them a cage, because a policy layer that an administrator sets is a policy layer he cannot remove. El Crítico's objection is narrower and sits between them: the decomposition is automatic, so the operator does not choose it.

La Jefa wins for any organisation that has ever answered a security questionnaire, and El Hacker is overruled on the estate while remaining right about his own laptop. Adopt, and set the token quotas before the first team is onboarded rather than after.

El Hacker normally punishes a closed source. Here he does not, because the model, the key and the endpoint are all his, and the vendor only supplies the interface. La Jefa's lower number is about the consequence of that arrangement: sixty developers holding sixty provider credentials is a key-management problem, not a licensing one.

She wins on the team question and he is overruled there, because personal keys do not survive an audit. He wins for an individual. El Crítico's warning about a closed extension holding those credentials is what turns her objection into the order. Adopt with conditions: keys issued centrally, never pasted per laptop.

El Crítico marks it down because the agent edits code and cannot run anything, so nothing it writes gets checked. La Jefa marks it up for the same reason: a tool that executes no commands is one she does not have to sandbox, and its settings can be fixed centrally.

La Jefa wins, because the missing capability is the same fact she is buying, and El Crítico is overruled on preference rather than on evidence. Adopt, if you keep the test run in the terminal where it already lives and do not expect this to close that loop for you.

La Inversora reads the ladder as a company that knows what it is worth. La Jefa multiplies the team rate and finds a number she can sign without a committee. Neither is arguing; they are confirming each other from different columns. El Crítico is the dissent, and his objection is narrow and sharp: the navigation is only as good as the project's own index.

El Crítico does not overturn them, he prices them. On a healthy Android project La Jefa wins outright; on a broken build his warning is the whole experience. Adopt with conditions, the condition being that the project compiles before you hand it a ticket.

El Hacker scores it highest and La Jefa lowest, and not over facts. He has Apache-2.0, local endpoints and a zsh plugin, so it travels in his dotfiles. She has a vendor account per developer and "no single sign-on, no audit trail". El Crítico adds that no container isolation is documented.

It is a terminal client for one developer, so El Hacker's reading wins and La Jefa is overruled at that scale; her not yet still holds at sixty seats. El Crítico's blast radius is the live condition. Adopt with conditions, the condition being a disposable branch per session and no team rollout until an administrator can see the accounts.

El Profesor and El Crítico read the same design and reach opposite conclusions about the same discard. He calls the ephemeral worker a principled way to keep tool output out of the planner; El Crítico calls it an edit made by something that will not be around to explain itself. Both descriptions are of one mechanism.

El Profesor wins on the design and loses on the practice: the structure is sound and El Crítico's missing safety net is the reason it bites. La Jefa's objections are real and aimed elsewhere. Trial only, and the trial ends the first time a discarded worker leaves a change you cannot explain.

El Hacker rates it near the ceiling because a single file with no configuration format is a file he reads in an evening. El Crítico rates it down for exactly the same reason: every change he wants is a fork he then maintains himself.

El Hacker wins for the person this was built for, who runs a small model at home and needs the context window for code rather than scaffolding. El Crítico is overruled on audience. Adopt, if you are running local weights; if you are not, the thing that makes it good stops applying to you.

The app is free and El Hacker gives cost a ten; El Crítico gives it a four, because the headline move fans one prompt across five agents and four of five runs are discarded and all five are billed. La Jefa adds telemetry collected by default.

They are scoring different meters. El Hacker prices the app, which is zero, and El Crítico prices the subscriptions underneath, which is the bill you actually receive. El Crítico wins and El Hacker is overruled on cost, not on the CLI. Adopt with conditions: telemetry off in a managed config, and fan-out reserved for hard problems rather than every ticket.

El Crítico and El Amigo agree on what a pane is and disagree about what it protects. He points out that a worktree isolates files and not ports, caches or build outputs; El Amigo counts the automatic teardown as the reason to keep three agents running at once.

El Amigo wins on the daily case and El Crítico owns the condition: the isolation is real up to the point where two panes want the same port. La Jefa is right to stop at the remote host. Adopt with conditions, the condition being distinct ports and build directories per pane before you run two servers.

La Jefa values one session schema because it turns six different agents into one thing she can log, review and account for. El Crítico values it less because normalising six agents means exposing what they share and hiding what makes any of them distinctive. El Profesor supplies the part neither disputes: the contract is written down and machine-readable.

La Jefa wins, because the buyer for a control plane is an organisation and not a power user, and El Crítico's loss of expressiveness is what she is purchasing on purpose. Adopt, if you pin the version El Crítico flags and read the changelog before moving off it.

The panel is within two points. El Hacker checks for a hollow core and does not find one: Apache-2.0 on the whole thing, one setup command, local endpoints. La Jefa's objection is not the $1,500; below the negotiated tier the escalation path is a public repository, which cannot be an incident process.

El Hacker's self-hosted route is La Jefa's remedy: an internal owner replaces the escalation path she cannot buy. She is overruled on the seat count, and El Crítico's weekly credit refresh is a reason to pay for the evaluation month, not to skip it. Adopt with conditions: self-hosted, one named owner, escalation agreed in writing.

El Hacker sits nearly two points below El Amigo and La Inversora, and the disagreement is the licence. He reads Elastic License 2.0 as honest but not his: he can build it and cannot host it. El Amigo does not price the licence at all, only the in-app browser beside the diff.

El Amigo wins, because a desktop supervisor is not a thing you host, and El Hacker is overruled on relevance rather than on fact. El Crítico's limit stands: no container layer, so a hundred agents share one machine. Adopt with conditions: a handful of worktrees until remote leaves beta, and La Jefa's Enterprise price in writing before rollout.

El Amigo scores it well because you can read the entire thing and then trust it, which is a property no other tool on this board offers. El Crítico marks reliability down for the corollary: the protections a production agent needs were left out on purpose, and nothing warns the user at the moment they matter. La Inversora is the only one thinking about who paid for it.

El Crítico wins on deployment and El Amigo wins on purpose, because the tool is honest about being a study object and users are not. Adopt with conditions: read it first, then use it on repositories you have committed.

La Jefa and El Crítico look at the same CI job. She sees a review step that finally fits the pipeline she already runs; he sees an exploration loop with no stated iteration limit running inside it. El Hacker's point about client-side execution reconciles them.

La Jefa wins, because the loop El Crítico fears runs on a machine she controls, on a timeout she sets, against a model she chose. He is overruled. Adopt, on the condition that agent mode carries a job timeout and that somebody measures the false-positive rate on your own repository before it becomes required.

El Crítico and El Hacker agree the product is open and disagree about what that buys you. He counts the surfaces it touches, browser, terminal, desktop applications, files, and scores reliability low because nothing stands between them. El Hacker counts the same list as reach and scores usefulness high. El Amigo sits with El Hacker.

El Crítico wins here, and El Hacker is overruled on the point that source access is a safety property. Reading code does not stop a command. Adopt with conditions: keep it on a repository you could throw away until you have watched a full session end to end.

El Crítico and La Jefa looked at the same pipeline and saw different sentences. She sees a review step that runs headless and costs no seats; El Crítico sees the flag it takes to make one of those runs work, which disables approvals and the isolation around them.

El Crítico wins the narrow point and loses the wide one: the flag applies to one caller, not to the tool. She is right that this belongs in CI; he is right about which door it must not come through. Adopt with conditions, the condition being that no pipeline invokes it through the path that requires the bypass.

El Amigo and El Crítico describe the same feature and disagree about what it is. He calls shared sessions the thing that finally makes agent work a team activity; El Crítico calls a permission prompt anyone can answer an authority nobody owns. La Jefa lands with El Crítico and adds that there is no directory behind any of it.

El Amigo is overruled for teams and right for pairs: two people who trust each other lose nothing, and ten do. Adopt with conditions, the condition being that approvals are restricted to named people before the instance is shared beyond the people already sitting together.

The spread is three and a half points, but the argument is between El Profesor and El Amigo. El Profesor reads the vendor's own figures, precision 49.2%, and concludes the tool is neither a filter nor a net. El Amigo reads the same number, scores 7.75, and says you will learn to skim.

El Profesor is right about the number and El Amigo is right about the reader: a second opinion that is wrong half the time is still an opinion nobody was getting. El Hacker is overruled; he wants to read a prompt, not a diff. Adopt with conditions, one-click fixes off for anyone junior, as El Crítico requires.

El Hacker reads that API keys do not unlock cloud features and concludes his key buys nothing. La Inversora reads the merge into the ChatGPT desktop app and calls it the safest closed bet on this board, with zero leverage for you.

For anyone already on a ChatGPT plan La Inversora wins, and El Hacker is overruled: he is refusing a machine he was never going to own. El Crítico is not overruled, and his objection sets the terms, since each environment holds your secrets behind a network policy configured once. Adopt with conditions, scoped tokens, the network defaulted off, and La Jefa's credit ceiling before rollout.

El Profesor scores reliability high because the pipeline names its phases and its retries, which is more discipline than this category usually shows. El Crítico scores it lower for a reason that does not contradict him: the processes being supervised belong to other projects, so liveness is inferred rather than known. La Jefa cares only that it runs without a terminal attached.

El Crítico wins on the specific claim and El Profesor wins the ruling, because inference about a child process is the normal condition of every supervisor ever written. Adopt with conditions: run one repository through it end to end before you point it at a real backlog.

The panel is narrow here, a point and a half, and the agreement is the finding: nobody thinks this is finished. El Crítico dates the problem, a platform one quarter old after a pivot from review bot to agent cloud. El Profesor wants the gatekeeper's false-positive rate and does not get it.

El Profesor's reading wins because it names a test a buyer can run. La Jefa is not overruled: her missing SSO and retention terms are why this stays a pilot. Trial only, exiting when the false-positive rate on your own repository is measured and two quarters of changelog exist.

The panel agrees on the engineering ergonomics. Flue provides a clean TypeScript hook model with durable session recovery and Model Context Protocol client support across Node.js and Cloudflare Workers. The split is operational governance. La Inversora prizes zero software fees, while La Jefa and El Crítico emphasize the unmetered API billing and unisolated local filesystem access during autonomous loops.

For platform engineers constructing internal pipelines, La Inversora's reading wins. For production deployments with open budgets, La Jefa's caution stands and overrides the open-source discount. Adopt with conditions: enforce upstream API spend caps and isolation layers before running agents.

The split is two points. La Inversora scores it highest, on a retention feature that never has to win. El Hacker scores it lowest: a closed plugin metered in credits, a CLI on his own Ollama. El Crítico names the shared complaint, the licensing page prices chat generations, not agent runs.

El Crítico wins, and El Profesor supports him from the other direction, the benchmark measures the model and the debugger measures the harness. La Inversora is overruled on cost, a meter nobody can forecast is not priced by attachment. Adopt with conditions, the two-team pilot La Jefa asks for, measuring credits per task before the pool is sized.

El Hacker scores lowest because there is "nothing to fork, nothing to run offline" and every prompt is a credit deduction. La Inversora scores highest because the parent is Amazon Web Services and "the parent is the exit". They are pricing the same closed box as abandonment risk and as procurement certainty.

For a team already on AWS, La Inversora's reading wins and El Hacker is overruled: the lock-in he refuses is an invoice you already sign. El Crítico's finding survives either way, since --trust-all-tools removes the only approval gate the CLI has. Adopt with conditions, the conditions being automatic overage disabled and an explicit tool list in CI.

Six critics inside three quarters of a point is agreement, and agreement is the finding. What it hides is El Crítico's folder: authentication lives under the Mastra Enterprise License, and authentication "is what stands between a demo and a deployment".

El Hacker reports that the grudge he brought did not survive, but he is scoring the Apache-2.0 half, so he is overruled on cost: the piece you need on the day you deploy is the piece that is not open. La Jefa's ordering, framework now and platform after a retention review, is correct. Adopt with conditions, the condition being LICENSE.md's directory mapping read before the first commit.

El Crítico reports that "Anthropic blocked OpenCode because of this project", so the host has been cut off once already. La Jefa finds the install bundling servers that send code searches to Exa, Context7 and Grep.app. El Hacker is precise where the badge is not: the licence is source-available, not open.

El Amigo scores it highest because the setup "arrives tuned", and he is overruled on the default configuration, since what arrives tuned also arrives pointed at three parties nobody read the terms of. La Jefa's data-flow review is the gate. Adopt with conditions, the conditions being those search servers disabled until the review and a second provider configured.

El Profesor scores the design high because the verification path is specified: high-risk calls can be planned, executed and checked, with evidence recorded. El Crítico scores reliability low because all of it is passive until somebody switches it on, and a control nobody enables is documentation. La Jefa cares only that an administrative surface exists at all.

El Crítico wins on the deployment question, because defaults are what most installations actually run, and El Profesor is overruled on nothing except optimism. Adopt with conditions: enable the approval path and the verified mode on day one, or you have adopted a different product.

Five critics land between 6 and 8 and El Hacker sits at 3, which normally signals a split worth arbitrating. It is not one. El Profesor and La Inversora are describing the same advantage from different angles: the evidence this agent reasons over is production telemetry the customer already generates, and no open licence would give El Hacker access to that.

He is overruled on relevance, not on principle. El Crítico's constraint is the real limit, and it is a factual one rather than a judgement: check your code host before you plan around this. Adopt, if your errors already land here and both hosts on your list are the cloud versions.

La Inversora reads a free plugin attached to a cloud platform and sees a funnel that will be funded indefinitely. La Jefa reads the same page and finds credits denominated somewhere she does not budget, which stops her before quality is ever discussed. El Crítico supplies the practical complaint: three products share this name and they do not share capabilities.

La Jefa's objection wins for any buyer outside the vendor's home market, because a price you cannot compare is a price you cannot approve. La Inversora is upheld on survival and overruled on relevance. Trial only: install the free plugin, and do not plan a rollout around the paid editions until the rate card is legible.

El Hacker rates it near the top because the licence is permissive, the model can be one he serves himself, and the extension points are open. El Crítico rates reliability lower because a tool that runs commands and touches git describes no isolation anywhere in the row. La Jefa adds a duller objection about which platforms it reaches.

El Hacker wins for a machine with one owner, and El Crítico is right the moment the machine has credentials on it, which most work machines do. Adopt with conditions: run it in a checkout you have committed, and keep it off anything holding production access.

El Crítico reads the catalogue and sees surface area nobody can keep current. El Profesor reads the same catalogue and sees four model abstractions behind one interface, which is a different claim about the same page. They are both describing breadth; only one of them counts the maintenance.

El Profesor is right about the design and El Crítico is right about the cost of it, so the ruling follows La Inversora: a JVM team that reads the primary repository can take this, a team that expects its home to be GitHub cannot. Adopt with conditions, the condition being that you pin the version and read the source first.

El Profesor scores this highest on the board for measurement discipline: the harness is evaluated across model families, under the leaderboard's own constraints, with the build and the raw run published. El Crítico does not dispute any of that. He objects to a subagent mechanism that works by the agent invoking itself, with nothing documented bounding the depth.

El Profesor wins on the claim under argument, which is whether the numbers can be trusted, and El Crítico is right about a separate thing that no number covers. Adopt, if you set a spend ceiling at your provider before you let it spawn anything.

The panel agrees, 1.75 points end to end, with El Hacker at 8.25 for MIT and a process that is YAML in the repository. The cost of that agreement is El Crítico's caveat: isolation is a git worktree, so parallel runs share one machine, one network and one set of credentials.

El Crítico is right and is not a reason to refuse: a worktree is the isolation a single repository needs. La Jefa is overruled; her Windows engineers are a staffing fact, not a defect in the tool. Adopt with conditions, the condition being credentials scoped to what every parallel run may safely share.

El Profesor refuses the headline number because nobody published a denominator, and he is right that resolved is not a measure of correctness. La Inversora does not dispute the methodology; she is pricing the effect the number has on buyers, which is a different question and a fair one.

He wins for the engineer deciding whether to trust it, and she is overruled there. El Crítico's condition binds the rollout: a model as a required check can block a release. Adopt with conditions, the condition being advisory mode until you have measured its false positives on your own repository.

El Crítico marks it down for the missing boundary around edits. El Hacker marks it up for the licence and the freedom to point it anywhere, and never raises the same objection, because he commits before he starts. La Jefa is closer to El Crítico: she wants the record, not the safety.

El Crítico is right for the reader who has not built the habit, and El Hacker is right about himself and nobody else. The tool is small and the gap is real. Adopt with conditions: commit before every session, so the boundary exists even though the tool will not draw it.

La Inversora reads a metered review line above a per-seat subscription as the growth engine, and she is right about the company. La Jefa reads the same structure as two budgets where she wanted one, and she is right about the forecast.

La Jefa wins for the buyer and La Inversora is overruled on the purchase, because a variable line item on a fixed seat price is how quality tooling becomes a surprise. El Crítico's finding sets the condition: this agent commits to your branch. Adopt with conditions: metered review capped, and automatic commits reviewed by a human.

The split is 2.75 points and it runs along the install boundary. El Hacker scores it highest: Apache-2.0, built from source, pointed at his own Ollama box. La Jefa scores it lowest: sixty desktop installs are an endpoint-management obligation, $1,200 a month before credits. El Crítico names the hazard both are circling: no sandbox in the design.

El Hacker's reading wins for the individual, and La Jefa is not overruled so much as answering for a fleet this tool has no console to manage. The absent boundary decides the condition. Adopt with conditions: run it from source with your own key, on a machine that holds no production credentials.

The split is 2.5 points and it is about ownership. El Hacker scores it lowest and still calls it the proprietary agent I resent the least, because BYOK reaches his Ollama box. El Crítico names the real hazard: rolling rate limits the pricing page does not publish, so the failure mode is being stopped, not being billed.

El Amigo and La Jefa win: a team standardising on one agent across terminal, Slack and CI gets more from that consistency than it loses to a closed binary. El Hacker is overruled for the team. Adopt with conditions, the conditions being BYOK mandated and the rate limits written into the contract.

The panel is a point and a quarter apart and the agreement is uncomfortable: the tool is good and the vendor has moved on. El Profesor and El Hacker both score the architecture highest, sandboxing and a 1M window. El Crítico scores lowest for the reason he states plainly, the successor gets the fixes.

El Crítico's risk is real and La Jefa is the one overruled: refusing to train sixty engineers is right for a fleet and wrong for the engineer who already holds a paid key. El Amigo's narrower reading wins. Adopt with conditions, a paid key or Code Assist license, and read the commit log each quarter.

El Hacker and La Inversora read the same closed product in opposite directions. He scores it low because nothing here is his and the key-bring option sits at the top tier. She scores durability high because Sonar is buying the company, which is precisely what makes his complaint permanent. El Crítico raises the harder objection: the reviewer and the committer are one actor.

For a team that already buys static analysis, La Inversora's reading wins and El Hacker is overruled; ownership was never on the table. El Crítico is not overruled, he is the condition. Adopt with conditions: auto-approve stays off until you have read a month of its commits.

The split runs 3.25 points between La Inversora, who scores Google's distribution, and El Hacker, who scores a proprietary IDE with no key field and gives it a four. El Crítico is the one describing the machine: agents drive your editor, terminal and a live Chrome, and the isolation on offer is a git worktree.

La Inversora wins on whether it will exist and loses on whether it is finished: no benchmark from El Profesor, no seat price from La Jefa. El Hacker is overruled on ownership and vindicated on caution. Trial only, the exit criterion being a published seat price for the Organization plan.

El Crítico and La Jefa reach opposite conclusions from the same loop. He warns that rules learned from merged history preserve whatever the team already tolerated; she approves the thing because it lands in a path sixty engineers already walk. Neither is describing a different tool.

La Jefa wins on adoption and El Crítico wins on the condition attached to it: the risk he names is slow and cheap to catch, and it is caught by reading the rules the system writes, not by rejecting the system. Adopt with conditions, the condition being that no synthesised rule takes effect without a human approving it.

El Crítico's finding is the one to act on: the preview channel feeds a running page's own content back to the agent, which turns whatever that page renders into instructions. La Inversora's figures say this is not a curiosity with nine users but a tool a great many people already have installed, which raises the cost of the same flaw.

El Crítico wins and La Inversora supplies the reason he wins. El Amigo's enthusiasm for racing several models is not overruled, only repriced, since he is spending five bills to find out. Adopt with conditions, the condition being that the preview never points at a page you do not control.

El Profesor's complaint is that the quantities driving every decision here are named and never specified, so a reader cannot tell what a passing score means. El Crítico's is that the machinery runs several models over every task, turning a small change into an expensive one. Both point at the same design from opposite directions.

El Profesor wins on rigour and El Crítico on economics, and neither is overruled: the tool asks to be trusted about correctness while declining to publish its units. La Inversora's reading of who funds it explains why. Adopt with conditions: route the gate to cheap models first, and measure the extra spend for a fortnight.

El Amigo scores usefulness high for the branching model, which is a genuine improvement over a linear transcript. El Crítico scores reliability low because a local server holding provider logins has no authentication described anywhere in the row. La Inversora is arguing about something else entirely: whose users these are.

El Crítico wins, because his objection has a cost today and hers has one next year. El Amigo keeps his marks; nothing he praised is in dispute. Adopt with conditions: bind it to the loopback interface only, and never leave it listening on a network you share.

El Crítico and El Profesor are both circling the same silence. He wants to know what the isolated environment is actually made of; El Profesor observes that the tool never writes a line, so everything you get is the dispatched agent's work. Together they describe a manager whose only claim is separation nobody has specified.

El Crítico wins, because a claim that cannot be inspected is a claim you have to test yourself, and La Jefa's credential objection points the same way. Trial only, and the trial ends when you have run two tasks at once and confirmed what the isolation actually holds.

Three and a half points. El Hacker scores lowest: closed, no key of his own, and the extensibility budget is one mcp.json file. La Jefa scores near the top because identity rides the Atlassian account she already administers, so SSO is done, and the models carry zero-data-retention terms.

For a shop whose tickets are already in Jira, La Jefa wins and El Hacker is overruled: the ownership he wants was traded away when the suite was bought. El Crítico's meter is the live risk, since a retrying agent pays per attempt. Adopt with conditions: an overage cap set before the pilot, reviewed monthly.

El Hacker scores it highest and concedes the problem himself: more surface than he will ever configure. El Crítico prices that surface, 210 MCP tools whose schemas cost tokens on every turn. El Profesor checks the numbers and finds the 1953 figure is a ratio of startup costs, not of outcomes.

El Crítico wins on his own remedy: one server group at a time. El Hacker is overruled on scale, not on the licence, and La Jefa is right that twelve background workers are spend nobody scheduled. Trial only, one engineer, one server group, and the exit criterion is a task completed cheaper than the same task without the swarm.

El Hacker scores cost at the ceiling because the whole thing runs against a model on his own hardware with nothing leaving the machine. El Crítico takes the accommodation that makes this possible and calls it the risk: parsing tool calls in several formats means accepting output that is not quite right and acting on an interpretation of it.

El Hacker wins, because the alternative for a small model is not stricter parsing, it is no agent at all, and El Crítico is overruled on the counterfactual. Adopt with conditions, the condition being that you review every diff, since the parser is guessing on your behalf.

El Hacker reads a strong copyleft licence and a provider list that ends on his own machine, and scores accordingly. La Jefa finds several capabilities are build-time options, so two engineers on the same version have different software. He calls that configurability. She calls it a support matrix.

For one engineer he wins and she is overruled, since he is the person choosing his own flags. Across a fleet she wins outright, and El Crítico's finding about the protection falling back quietly makes her case sharper than she made it. Adopt with conditions: one published build per team, and pass the flag that makes isolation mandatory rather than best-effort.

El Amigo scores usefulness high because five agent CLIs under one key map is the daily win. El Crítico is not disputing that. He is asking who reconciles the branches when four sessions finish at once. El Hacker sides with El Amigo for the reason that matters to him, which is that nothing here is a black box.

El Crítico is right and narrow. The merge problem he names is a git problem, not a defect of the manager, and it arrives only when you actually run four agents. Adopt, on the condition that you keep one session per concern and merge as you go.

The panel does not argue about what this is. El Hacker scores it high because the licence lets him point his own clients at the editor. La Jefa scores usefulness low because the same surface is a control plane with no account behind it. El Crítico sides with her for a different reason: the thing being controlled belongs to somebody else's extension.

El Hacker wins for a workstation, and La Jefa is overruled only on the desk of the person who owns it. Her objection stands the moment it leaves that desk. Trial only, and the exit criterion is a week of driving it without the editor falling over.

El Hacker scores the AGPL-3.0 copyleft and the bundled MCP server package high. La Jefa reads the same row and finds no SSO, no audit trail, and an installer to push to sixty machines. He is buying a tool. She is buying an estate.

For one engineer driving several runtimes at once, El Hacker wins and La Jefa is overruled: a free desktop app costs nothing to walk away from. For the company she wins, and El Crítico's caveat binds her alone, since this app inherits whatever the agents underneath it do. Trial only, two engineers for a quarter, dropped if the review UI misses bad hunks.

La Jefa and El Amigo score this four points apart and neither is reading it wrong. She sees role-based access, single sign-on, audit logs and spend caps per team, which is the list her security questionnaire asks for. He sees a platform that a single developer has no reason to install. El Crítico names the cost both of them skipped: somebody has to run the cluster.

La Jefa wins, because this was built for her and El Amigo is answering a question it never asked. Adopt with conditions, the condition being an existing platform team that already operates Kubernetes; without one, El Crítico's objection becomes the entire project.

The spread is 3.75 points. El Hacker scores it highest, MIT, nineteen providers including Ollama for a fully local run. La Inversora scores it lowest, a community fork living under the parent's own GitHub org. El Crítico locates the seam: the WebContainer API needs a commercial license for production commercial use.

El Hacker wins for personal use and is overruled the moment money is involved, because the runtime he cannot fork is the one he needs a licence for. La Inversora is right about the project and wrong about the risk. Adopt with conditions, the condition being a WebContainer commercial licence bought before anything ships commercially.

El Hacker takes the whole thing on its licence and its install command. La Jefa finds no identity, no central visibility and two supported operating systems, and marks it down for being a personal tool. She describes it accurately and reviews it for a job it never applied for.

El Hacker's reading wins and La Jefa is overruled, because this is bought by an individual and installed by an individual, and her objections cost the company nothing when the licence line is zero. El Crítico's warning survives the ruling and binds everyone. Adopt, provided you know which keystroke deletes a worktree before you learn it by accident.

El Hacker scores it 8.25 and La Inversora 4.50, and they agree on the facts. He says forking is a go build; she says smtg-ai is a repository, not a company, and expects absorption rather than a roadmap. For a free binary that wraps agents you already pay for, her risk is cheap.

El Hacker wins and La Inversora is overruled: you cannot be stranded by a vendor that does not exist. El Crítico is not overruled: --autoyes answers every prompt in every pane with no container underneath. Adopt with conditions, the condition being that -y stays off and the tool stays personal, as La Jefa ruled.

The disagreement is three points wide and turns on the buyer's tolerance for risk. El Hacker sees an open-source, MIT-licensed harness he can own and fork. La Jefa and La Inversora see a university project with no commercial support, no central management, and an uncertain future. They are not disagreeing on the facts; they are disagreeing on what constitutes a reliable foundation for work. El Crítico's point about the missing browser is noted but secondary to this main question of viability.

For a team requiring vendor support and central administration, La Jefa is correct and El Hacker is overruled. For an individual developer or a research team comfortable with maintaining their own tools, El Hacker's reading wins. His score reflects a user who sees a lack of a vendor not as a risk, but as freedom. The project is new and its capabilities are not yet proven against public benchmarks, making any adoption a bet on its architecture.

El Crítico's objection is what the tool asks for before it works. La Jefa's is what it costs once it does, and she reaches a number she can defend, which he never considers. El Profesor scores the precedence design highest on the panel and is arguing about a mechanism neither of the other two disputes.

El Crítico wins the ordering: an access grant and an hour of indexing come before any budget conversation, so his gate is the first gate. La Jefa is not overruled, she is next in the queue. Trial only, and the exit criterion is one repository you would not mind a stranger reading.

El Hacker scores it well because the licence is permissive and an outside provider can be configured in place of the built-in one. La Inversora scores longevity lower because the default path runs on the vendor's own inference behind a key, which is where the revenue has to come from eventually. Neither disputes the other's fact.

La Inversora wins the longevity question and El Hacker wins the practical one, because the escape hatch he names is real and available today. Adopt with conditions: configure an external provider before you build a habit, so a future price list is an inconvenience and not a migration.

El Amigo scores usefulness high because an agent that runs the notebook is different in kind from one that writes cells into it. El Crítico scores reliability low because the same agent executes shell commands as whoever owns the server. La Jefa arrives at El Crítico's position from the other end, worrying about where that server lives.

They are right together, and El Amigo is not overruled, because the capability he values is the capability they fear. There is no version of this without both. Adopt with conditions: on a single-user machine only, never on a shared notebook server.

La Inversora scores durability at 9 because the sponsor's motive is obvious and permanent. El Crítico scores reliability at 5 because the performance primitives do not merely watch a workflow, they change how it executes. El Profesor sides with the design and notes the harder gap, that a toolkit built to measure agents publishes no measurement of itself.

El Crítico is right about the category error and wrong about the consequence: an optional layer you can remove is a different risk from one you cannot. He is overruled on severity, upheld on the warning. La Inversora's reading carries. Adopt, with the accelerators off until you have a baseline to compare against.

The split is between El Hacker and La Jefa. He sees a powerful, local-first, open-source tool that respects his ownership. She sees sixty individual desktops with no central controls, no audit logs, and no SSO. El Crítico shares their concern, noting the security risk of running powerful agents without a documented sandbox. This is not a disagreement about the tool's function, but about who is responsible for managing the risk it introduces: the individual user or the organization.

For an individual developer or small team comfortable managing their own security, El Hacker's reading wins. The tool's power is a feature, not a bug, and the risks are yours to own. For any organization looking to deploy this to a larger team, La Jefa is correct and the lack of enterprise features makes it untenable. El Hacker is overruled on the grounds of team scale. Adopt for personal use; avoid for managed corporate environments. The lack of a sandbox is a known risk for either user.

El Profesor marks the published comparison down because the rubric, the sample and the scoring all belong to the vendor, so the number describes a preference rather than a result. La Jefa scores it higher than she scores anything in this category, because budgets and approvals exist here at all. El Crítico sides with El Profesor.

La Jefa's reading wins for teams and El Profesor is not overruled on the number, which should be ignored entirely. The governance is the reason to look; the score is not. Trial only, with the exit criterion being your own measurement on your own backlog.

El Amigo's case is the checkpoint mechanism: an agent whose work can be rewound is an agent you can let run. El Crítico's case is that the same code claims to support a span of language versions no small team can test, so behaviour on any given one is a hope, and checkpoints are the feature you least want version-specific.

El Crítico wins on sequencing: the undo has to work before it earns trust, and El Amigo is not overruled so much as made conditional. El Hacker's protocol coverage is the best thing here. Adopt with conditions, the condition being that you verify a rewind on your own runtime first.

El Hacker sits three points under El Amigo and they are not arguing about the review. He notes the extension proxies through their cloud even for uncommitted diffs. El Amigo prices the same fact as convenience: one reviewer follows the change from the editor to the pull request.

El Amigo wins and El Hacker is overruled; he is pricing ownership, which a review seat does not sell. La Jefa sets the terms. Adopt with conditions: SSO, SCIM, audit logs and retention in writing before the seats, and El Crítico's GitLab gap means the status check is advisory until it closes.

El Amigo is highest and La Jefa lowest over the same vendor. He calls it the cheapest IDE seat on the board, subagents and MCP included, and names the vendor as the trait that decides it. La Jefa reads the pricing page: enterprise means contacting BytePlus, no SSO, no audit log, no retention statement.

El Amigo wins for the individual and La Jefa is not overruled for the company, since her objection is paperwork that does not change. El Crítico's condition binds both: allowlisted prefixes are built to walk through the sandbox, so keep deploy manual. Trial only, on personal projects, ending at the first line of work code.

La Inversora scores longevity high because a large technology company's platform group does not abandon a framework the way a startup does. El Profesor is unmoved, because the feature list claims evaluation and benchmarking as capabilities and publishes no numbers produced with them. El Crítico lands nearer him, counting the surface area.

La Inversora wins on survival and loses on evidence, which is the correct split: the project will still exist and you still cannot tell how well it works. Adopt with conditions, the condition being your own evaluation run before anything of yours depends on it.

The split is 4.5 points and it is about who is buying. La Inversora scores 8.25 on a funnel: every generated app deploys to the parent, so the price can rise without churn. El Hacker scores 3.75 because the models are Vercel composites he cannot replace, and grants only the MCP server and the SDK.

For a shop already shipping Next.js on Vercel, La Inversora's reading wins and El Hacker is overruled: the lock-in he prices is one you bought on purpose. El Crítico's meter is the live risk. Adopt with conditions: frontend seats only, a hard credit cap, and the training opt-out verified before the first prompt.

The panel agrees inside 1.5 points and El Crítico names the inconsistency: self-hosting is offered for the console and withheld at the model, so an agent on your own hardware still ships every prompt to one of three providers. El Hacker is highest because the tool registry speaks MCP natively, with no adapter in between.

El Hacker wins on the framework and El Crítico is overruled on the score, not on residency: the console self-hosted answers where traces live, not where prompts go. La Jefa's terms are the order. Adopt with conditions: the console on your own infrastructure, provider terms read, and a support arrangement in writing before anything customer-facing.

El Profesor gives this the highest marks he has given a benchmark claim, because the harness, the date, the model and the tool set are all disclosed. El Crítico's objection sits beside that rather than against it: the deployment ships as containers with no per-task boundary described, so the thing you run is not the constrained thing that was measured.

Both stand, and El Crítico governs the deployment decision while El Profesor governs your trust in the claim. Adopt with conditions: give the deployment its own host, because the evidence applies to the score and not to the blast radius.

The panel agrees on the value of Atlas's core idea: source control for agent activity. El Hacker and El Amigo see a powerful, local-first workbench for orchestrating multiple agents. La Jefa, El Crítico, and La Inversora see a security risk and an unformed business model. The split is not about the tool's function, but about its audience. The lack of a sandbox for execution is the central point of contention, making it a dealbreaker for enterprise use but a calculated risk for an individual developer.

For an individual experimenting with agents on their own machine, El Hacker's reading wins. The risk of direct execution is manageable when you are the only user and the codebase is your own. For any team or organization, La Jefa and El Crítico are correct; the security and compliance gaps are too significant to ignore. The tool is not ready for procurement. Adopt with conditions, the condition being that it is used only by individual developers on non-critical, local codebases.

Agreement without warmth: 1.25 points from El Hacker's 6.00 to La Jefa's 4.75. El Crítico states the mismatch, the stars belong to a 2023 agent that now lives in a classic folder while the product on the landing page is a workflow builder with no shell. El Amigo puts it plainly, this one never touches a file.

El Amigo's boundary is the ruling: judged as a workflow platform it is a fair product, judged as the autonomous agent the stars remember it is gone. La Jefa blocks it and she is right to: the Team tier is marked coming soon. Trial only, the exit criterion being that tier shipping.

El Amigo scores portability high because the thing installs where nothing else will. El Crítico scores longevity low from the same sentence: everything underneath was written by hand, so every provider change lands on one person. They are not arguing about the code. They are arguing about how long one maintainer stays interested.

El Amigo wins for anyone whose problem is reaching a locked-down server today, and El Crítico is overruled on urgency rather than on risk, because his objection is a next-year problem. Adopt with conditions: pin the version you tested, and keep a second agent for the machines that do not need this one.

A point and a half covers the panel, whose ends grade different codebases. La Jefa found OIDC single sign-on and per-user isolation written down, more than most free projects offer. El Crítico found that 2.0 shares no code with 1.x, so the stars and the closed issues describe a side branch.

El Crítico wins and La Jefa's approval is deferred, not denied: a security document written for a rewrite is a promise until someone runs it. El Hacker is overruled on longevity: a file for every piece is not a history. Trial only, reading the 2.0 issues alone, exiting when a platform owner has run it a quarter.

La Inversora admires charging for delivered output rather than seats, because the vendor only earns when something lands. La Jefa points out the same structure means there is no free tier, so evaluation begins with a purchase order and a minimum commitment.

La Inversora wins on whether the model is fair and La Jefa is overruled there, since paying for results beats paying for logins. El Profesor's finding is the condition on both readings: coverage is the unit of account and coverage is not correctness. Adopt with conditions, the condition being a sampled human review of the generated suites before anyone reports a coverage number upward.

El Crítico's finding is that protection here is opt-in and that its network half applies on one operating system. La Jefa never reaches that argument, because her problem is arithmetic: per-token billing gives her no per-person cap and therefore no number to take to finance. El Profesor is the outlier, rating the interoperability rather than the risk.

Both dissenters are right about different readers and neither is overruled; El Profesor is overruled where he implies the design quality settles the purchase. It does not. Adopt with conditions: sandboxing enabled before the first session, a hard spend alert on the key, and Linux for anything that touches the network.

La Jefa scores this high because permissions, run history and backups exist as product features rather than intentions. El Crítico does not deny that. He points out that the containment applies to ordinary members and an administrator is documented as reaching the host directly, so the strongest role has the weakest boundary.

El Crítico wins on the narrow point and La Jefa wins on the whole, because a tool with two tiers is still ahead of the field that has one. Adopt with conditions, the condition being that the administrator role goes to one named person and never to a team alias.

El Amigo and El Hacker score this highly for the same reason: a loop small enough to read entirely, with everything else replaceable. El Crítico does not dispute a word of it and points at the discovery mechanism, which collects configuration by walking upward from wherever you are standing and repeats that on every iteration. La Jefa reaches his conclusion from the controls side.

El Crítico wins, and the elegance El Hacker admires is what makes the finding serious rather than minor. Trial only, and the exit criterion is a run inside a repository you did not write, with the discovered plugin set printed before anything executes.

The panel is a point and a half apart. El Crítico scores lowest on the install command, pip install --pre against a project that labels itself preview. El Hacker scores highest and still names the hole, no local model path. El Profesor likes the frozen intermediate representation and notes no benchmark accompanies it.

El Crítico wins on the word the project chose. La Jefa's internal pipelines only is right and premature, because the decorator signature can still move under her. La Inversora is upheld, build with it, do not build a roadmap on it. Trial only, a pinned version on an internal pipeline, ending when the preview label comes off.

El Profesor scores this near his ceiling because the prompt budget is measured and published, which almost nobody in this category does. El Crítico raises something the budget cannot answer: the unattended mode approves its own tool calls, so the cheapest way to run it is also the one with no gate in front of it.

Both hold. El Profesor's point is about design and El Crítico's is about deployment, and the reader will meet the second one first. Neither is overruled on facts. Adopt with conditions: use the interactive mode by hand, and restrict the unattended flag to a directory you can restore.

El Hacker scores the configurability well and stops short of calling it his, because the terms permit reading and forbid competing. La Jefa never reaches the features: a noncommercial licence means her sixty engineers need written permission before they open it at work, and requested permission is a procurement step whatever it costs.

For an individual outside work hours El Hacker wins and La Jefa is overruled. Inside a company she wins outright, so his score describes a tool most readers here cannot legally use as they intend. El Crítico's warning about unattended loops applies either way. Trial only, personal machines, and get the written licence before anything commercial.

El Crítico and El Amigo are looking at the same pairing. He sees a platform whose execution depends on a machine that can close its lid; El Amigo sees the reason to be here, which is that the agent already logged in on that machine is one you have already paid for. La Jefa splits the difference by refusing the paired half.

La Jefa's line is the one to follow, and El Amigo is overruled on the best part of his own argument: the convenience he likes is the fragility El Crítico names. Adopt with conditions, the condition being server-run agents for anything that must not miss.

El Profesor credits Landlock with mounts fixed at creation and a broker that names which binaries may reach a destination. El Hacker calls it "stricter than what I would have built, and better". La Jefa reads the overview aloud: not a hosted service, not a multi-tenant control plane, not an identity system.

The vendor settles this before the panel can. La Inversora reads the same label, early preview. La Jefa wins past a single host and El Hacker is overruled beyond his own. El Crítico says why: the controls hold only where the managed entrypoints run. Trial only, on one Linux host, until a fleet story ships.

El Amigo scores usefulness high because the output is real office files rather than text about office files, which is what the intended user actually wants. El Crítico scores reliability low because the containment applies to commands and the desktop control runs outside it. La Inversora raises a different concern entirely, about whose product this is defined against.

El Crítico wins the safety question outright and El Amigo keeps the usefulness one, because both are true of the same feature. Adopt with conditions: turn the desktop control off unless you are watching it, and keep the workspace folder somewhere you would not mind losing.

El Profesor scores this well because goals, traces, evidence and review state are modelled as one connected record rather than scattered across terminals. El Crítico agrees the model is good and points at the entry: coordination happens across three protocols, and what an agent contributes depends on which one it speaks. La Jefa is scoring the deployment.

El Crítico wins on the practical question, because a system of record with gaps is a system of record nobody trusts, and El Profesor is overruled on completeness. Adopt with conditions, the condition being that every agent you connect speaks the same protocol as the others.

El Crítico marks this down because supporting many language versions and several host frameworks is an enormous matrix for one project to keep working. La Jefa marks it up for exactly that reason, since every one of those hosts is already in her estate and nothing new has to be introduced to use it. El Hacker is scoring the protocol support.

La Jefa wins, because breadth is a maintenance problem for the authors and a compatibility gift to the reader, and El Crítico is overruled on whose risk it is. Adopt, if you pin the version and re-test the integration on every host framework upgrade.

El Crítico marks it down because execution happens on your machine unless you deliberately reach for another mode. El Hacker likes precisely that, since a container between him and his own files is friction he never asked for. El Profesor stays out of it and grades the context handling instead.

El Hacker is right about his laptop and wrong as general advice, because a framework's default is what most people ship. El Crítico wins on the default and loses on the principle. Adopt with conditions, the condition being that the sandboxed extra is installed before any code the model wrote runs.

El Crítico's objection is precise and small: the plan labelled free is not a free plan, and the documentation says so where the marketing does not. La Inversora treats the same ladder as a company that has worked out what its heaviest users are worth. Neither is arguing about the product, which El Profesor scores well on its own merits.

El Crítico wins, because a buyer who believes the label will plan around a clock that stops after a week. He does not overturn El Profesor, he delays him. Trial only, and the exit criterion is a full parallel run finished before the trial credits are gone.

El Profesor scores the design well because every task declares what it accepts and what it returns, so a break is caught at the seam. El Crítico answers that branching, loops and error handling expressed through a builder are harder to debug than the same logic written plainly, and that you now debug both.

They are both right and the tiebreak is who else reads the flow. El Profesor wins where several people maintain a pipeline and the schemas are the documentation; El Crítico wins for one author. Adopt with conditions, the condition being that a flow stays small enough to read on one screen.

El Crítico scores reliability low because everything here was rebuilt from nothing, which means every failure the category already solved has to be rediscovered in this codebase. La Jefa scores usefulness high for a reason he does not contest: a command centre that aggregates sessions, agents, cost and worktrees across machines is the closest thing to a console anyone offers her.

El Crítico wins first, because an untested surface is a present problem and a console is a future convenience. Trial only, and the exit criterion is a month on one team with the per-agent budgets set and nothing having gone quietly wrong.

The split is between El Hacker and La Jefa, and it is a category argument rather than a factual one. He scores the licence and the build near the top because a C library is his to compile and fork. She scores usefulness low because a library never appears on an invoice or in a pipeline she can measure. El Crítico sits between them, and his shell-tool warning is the only finding either should act on.

El Hacker wins, because nothing here was ever bidding for La Jefa's estate; she is overruled on relevance. Adopt with conditions, the condition being that the shell tool stays behind isolation you supply yourself.

The spread is two and a half points and it runs between El Hacker, who calls the licence honest and the loop patchable, and La Inversora, who sees a name and a mailing list with nothing to buy. El Crítico is the one asking the reader's question: v1.0 is not a drop-in upgrade and ag2-classic still ships.

La Inversora is overruled for anyone adopting the code rather than the vendor; she is pricing a company the reader is not buying. El Crítico wins. Adopt with conditions, the condition being the package name pinned in requirements and the port off ag2-classic budgeted before the first sprint.

El Profesor and El Crítico grade different halves of the same machine. He rates the transport highly because mutual authentication and a stateless relay are deliberate choices. El Crítico rates reliability low because the thing that keeps a pod moving is a loop with a counter on it. La Jefa is closer to El Crítico than to anyone.

El Crítico wins on the operating question and El Profesor is not overruled, because a sound transport underneath an unattended loop is still an unattended loop. Trial only, and the exit criterion is a week of autopilot logs with no pod burning its cap on the wrong ticket.

El Amigo and El Hacker land in the same place from different directions: one install, one machine, and nothing has to leave it. El Crítico files the dissent, and his objection is concrete. An agent can work unattended for an hour, the row records no git operations, and so nothing bounds what changed.

El Crítico wins the narrow point and loses the ruling, because the boundary he wants is one you can draw yourself before a run starts. Adopt with conditions: branch first, and never point an unattended session at a working tree you have not committed.

The panel agrees on almost everything, which makes the one disagreement easy to find. El Amigo rates the cockpit highly because watching a run is the point. El Crítico rates reliability lower because the autonomous flag exists precisely so that nobody is watching, and one tool cannot claim credit for both. El Profesor sides with neither and points at the state files.

El Crítico wins on the flag and loses on the rest, because El Profesor's plain-text state means a bad run is legible afterwards. Adopt with conditions, the condition being that autonomous runs stay off until you have read a supervised one end to end.

El Hacker scores this well on capability and badly on ownership, because the package declares no licence and points at no repository. La Inversora arrives at the same place from the cap table: no visible entity stands behind six paid tiers. El Amigo, scoring the daily experience, is right that the feature set is real and is answering a question neither of them asked.

El Amigo is overruled: a tool that runs shell commands and opens pull requests, and that you can neither read nor attribute, is not a preference. Avoid, with the condition that reverses it, a published licence and a named repository.

She rates it because the whole thing runs inside her own network, and he rates it because the licence lets him do that without asking. Agreement from those two is rare. El Crítico dissents, narrowly: he does not trust a review pass that finds code by resemblance.

El Crítico is right and overturns nothing, because his objection lands on one feature rather than on the assistant around it. La Jefa's reading wins for any team that cannot let source leave its own hardware. Adopt with conditions, and the condition is that a human owns the merge decision, never the review pass.

The spread is two points. El Hacker gets one mcp.json with hot reload and a Custom provider row for his local server. La Jefa counts five model categories routed to five vendors, which is five retention reviews instead of one, and finds no SSO in the open project.

El Hacker wins for one machine, La Jefa wins for sixty, and her not yet stands for the fleet. The fact that binds both is El Crítico's, quoting the maintainers themselves: the agent has access to your local operating system and belongs only in trusted environments. Adopt with conditions, personal use on a machine that holds nothing you value.

El Amigo grades the CLI that reviews uncommitted work from inside Cursor, Claude Code or Codex, and calls it review moved left of the commit. El Hacker grades ownership and finds a rented reviewer with a decent command line.

El Amigo wins and El Hacker is overruled, because a reviewer is a service and nobody was going to fork it. El Profesor sets the expectation from the vendor's own figures, precision 56.3%, so it is a net rather than a filter. Adopt with conditions, background agents enabled per repository as El Crítico requires, and La Jefa's SOC 2 Type 2 and SSO in writing first.

El Amigo scores usefulness high because a tool tuned for one model family has defaults that are actually right, instead of the generic middle every provider-agnostic agent settles into. La Inversora scores longevity low from the identical fact: a product shaped around one vendor's roadmap does not own its own future. El Crítico's objection is unrelated and smaller.

El Amigo wins for this quarter and La Inversora wins for next year, and since a terminal tool is not a five-year commitment, his reading governs the decision in front of you. Adopt with conditions: keep the endpoint settings portable, so the day the tuning stops mattering you can point it elsewhere.

El Crítico's objection is that the repository publishes documentation, installers and an issue tracker, so every assurance is a promise rather than an artefact. El Profesor agrees on the epistemics and separates the question: parsing a command before judging it is the correct approach whether or not he can read the parser.

El Crítico wins on trust and El Profesor is overruled on comfort, not on design, because a good architecture you cannot inspect is still an architecture you cannot inspect. El Hacker's escape hatch keeps this from being a refusal. Trial only: your own key, your own endpoint, and nothing sensitive until the source appears.

The split is three points between La Inversora at the top and El Hacker at the bottom. She sees a seat business attached to Google Cloud contracts, sticky and boring. He sees one key field and one server list, nothing I would build on. El Crítico supplies the fact neither disputes: agent mode cannot undo changes made outside the IDE.

La Inversora wins for a company already on a Google Cloud invoice, and El Hacker is overruled there; on his own machine he is right. El Crítico's line sets the condition. Adopt with conditions: yolo mode off, and the IDE's credentials scoped away from production.

La Inversora reads a tier list without amounts as evidence about what the vendor actually sells. La Jefa reads the same page as a procurement dead end and refuses to model a budget on it. El Profesor sets both aside and marks the loop high, because the loop is documented step by step and does not depend on knowing the price.

La Jefa is right that you cannot buy what you cannot price, and she does not overrule El Profesor, she postpones him. El Hacker's escape hatch is what makes the delay survivable. Adopt with conditions, the condition being a written quote for your seat count first.

No facts are disputed. El Crítico finds no shell execution and no multi-file editing on the row, so the real work is done by whatever agent it hosts. El Amigo reads the same absence and says the value was never editing: it is having the agent beside the conversations where the work is requested.

El Amigo wins for the reader who wants an assistant across their day; El Crítico wins for anyone shopping for a coding tool, which is most of this board, so he is overruled outside that group. La Jefa's cloud arithmetic caps the ambition. Trial only: the free desktop build, your own keys, no seats this quarter.

El Hacker rates it near the floor because nothing here is inspectable and no key of his goes in. La Inversora rates durability high for the same reason he complains: a vendor this size does not abandon a line aimed at its own installed base. El Profesor sits between them with the sharper objection, that the routing claim at the centre of the product is never substantiated.

La Inversora wins on survival and El Hacker is overruled on it, because a fork was never the offer. El Profesor is not overruled at all; his objection is the reason this is not an adoption. Trial only: one modernisation project, measured against a hand estimate, decided in a quarter.

El Crítico and La Inversora reach the same fact from opposite motives. He calls a single model vendor with no substitution a lock; she calls a model vendor giving away an SDK a distribution strategy working exactly as designed. El Hacker, who normally settles this, agrees with both.

La Inversora's reading is the useful one, because knowing why the SDK is free tells you what will not change: the client stays open and the model stays theirs. El Crítico is overruled on framing, not on facts. Adopt with conditions, the condition being that nothing you build on it assumes a second provider will ever appear.

La Inversora scores it highest, reading the $4,300 ladder and Lovable Cloud as "the switching cost every hosted builder wants". El Hacker scores it lowest: no shell, no key of his own, "nothing to fork". El Crítico prices the middle: a Build message can run ten hours and checks in only after twenty credits.

El Hacker is overruled: he is not the buyer and never was, and the MCP server is his concession. La Inversora wins for the product team with a deadline. El Crítico's default is the live danger. Adopt with conditions, the conditions being a lowered check-in threshold before the first task and a fixed credit budget.

The split is not about the facts. The panel agrees MindsHub lacks a sandbox, terminal, or git integration. The disagreement is about what this means. For El Amigo, El Crítico, and El Profesor, this makes it a tool for knowledge work, not software development. For La Jefa, the lack of a sandbox is a security risk that makes it unsuitable for teams. El Hacker sees an MIT-licensed workspace for users who want to host it themselves and bring their own models, accepting the trade-offs.

La Jefa's reading of risk wins for any team setting, and El Hacker's reading wins for a solo user who understands the security implications of running unsandboxed code. The core issue is that MindsHub's marketing implies software development, while its architecture supports only task orchestration. This is a tool for composing agent workflows, not for building software directly. Trial only, with the exit criterion being a successful demonstration of a multi-step knowledge work task that cannot be accomplished with a simpler tool.

El Profesor and El Crítico are describing one mechanism from two ends. He admires a reviewer instructed to refute rather than approve; El Crítico points out that a refuter with no round limit is a meter with no ceiling. El Amigo is holding the condition both of them need: the tests.

El Profesor wins on design and El Crítico wins on operations, which is not a split so much as an order of work: the design is only safe once the spend is bounded. La Jefa is overruled on relevance for an individual. Trial only, and the trial ends when a task costs more than the fix was worth.

El Crítico's finding is that development has been quiet since late 2025 while the tool it wraps ships constantly, which makes drift a certainty rather than a risk. La Inversora reads a rebrand and a repository that changed hands, and concludes the attention was spent rather than invested. El Hacker's copyleft answer is about rights, not maintenance.

Both dissenters win and El Hacker is overruled on practicality: the freedom to fix something is not the same as anyone fixing it. Trial only, on a machine where a stale wrapper cannot cost you anything, and re-check the repository before you rely on it for a second month.

El Hacker scores it highest: "a reviewer I cannot read is a reviewer I cannot argue with", and this one is Apache-2.0. El Crítico scores lowest on delegation mode, where the model that wrote the change can approve it. El Profesor notes the 200-pull-request comparison is self-authored, with no labelling protocol.

El Hacker wins: the reviewer runs inside your own automation and no third party holds the repository. La Inversora is overruled on longevity: the fork she tells you to keep answers the reorganisation she fears. Adopt with conditions, the conditions being a reviewing model different from the author's and false positives measured on two repositories first.

El Profesor rates the architecture well because binding each parallel worker to a different model is an ensemble rather than a gimmick. El Crítico rates reliability low because nothing in the row says where those workers write, and several of them are editing one project at once. El Hacker is untroubled, which tells you which desk he sits at.

El Crítico wins, because an unanswered question about concurrent writes is the kind that gets answered expensively. El Profesor is overruled on nothing except sequence. Adopt with conditions: commit before every run, and start with two workers until you have seen what they do to each other.

El Amigo and El Crítico are both looking at the permission ladder and only one of them is looking at the second week. He calls the three modes the reason to be here; El Crítico notes that a folder promoted once stays promoted with nothing documented about taking it back. La Inversora adds the part neither addresses: the price list belongs to one provider.

El Crítico wins, narrowly, because his objection is about the mechanism El Amigo is recommending rather than a different one. Adopt with conditions, the condition being that you keep a written list of which directories you have trusted and prune it.

El Amigo scores it well because adopting it costs nothing: your existing sessions and logins are already there when it opens. El Crítico scores longevity lower because everything underneath is packaged inside the application, so the version you run is chosen by the packager rather than by you. La Inversora notes the whole thing depends on another project.

El Crítico wins the long question and El Amigo wins the immediate one, since a tool you can stop using tomorrow does not need a five-year answer. Adopt with conditions: keep the underlying agent installed separately, so a stale bundle is an inconvenience rather than a wall.

The panel is within two points and agrees the security page is good. La Jefa calls kernel-level sandboxing on three operating systems the strongest here. El Crítico prices the other side: a rewrite in July 2026, three releases in eight weeks, and fifteen roadmap items in progress, among them multi-location file changes.

El Hacker's Tool Guard and Apache-2.0 are real and they do not answer El Crítico, whose items are the ones that keep a file intact mid-edit. He wins; El Hacker is overruled on the coding mode. Trial only, on the console and the chat channels as El Crítico advises, until those roadmap items ship.

El Profesor scores it near his ceiling because the pass condition is a command you wrote and the checks themselves are tested before any work starts. El Crítico agrees with all of that and marks reliability down anyway: many task directories, no commits, and nothing that brings the results back into one history.

Both are right and El Crítico is answering the question the reader asks second. Adopt with conditions: write the check before the task, and own a merge step of your own, because the tool deliberately ends at the verdict.

El Profesor scores it well for a single reason: symbols are resolved through a language server rather than guessed from text, which is a real answer to a real problem. El Crítico scores longevity lower by counting surfaces, and there are many, all maintained by one person. La Jefa cares about a third thing, which is where the traffic goes.

El Profesor wins on what the tool does and El Crítico wins on whether it lasts, which a buyer should weight less for a free terminal tool. Adopt with conditions: use your own provider endpoint, not a relay you did not choose.

The panel agrees more than usual and the disagreement that remains is small. El Profesor rates the compiler-checked tools highest; El Crítico's only complaint is a version constraint in the README, which is a five-character fix. La Inversora is the dissent: she thinks the platform owner ships this eventually.

Her risk is real and it is eighteen months away, while El Profesor's benefit is available this afternoon, so he wins and she is overruled on timing rather than analysis. Adopt with conditions, the condition being an exact version pin rather than the lower bound the install instruction gives you.

El Amigo scores it highest for the developer running several coding agents against one repository. La Jefa scores it lowest and says not yet: telemetry is on, it records which GitHub organisation owns the repository, and there is no SSO. El Crítico adds that the orchestrator handles CI fixes and merge conflicts on its own.

For one engineer on one machine, El Amigo wins and La Jefa is overruled: her blockers are procurement blockers and there is nothing to procure. At sixty seats she is right and the ruling flips. Adopt with conditions: telemetry off, and no merge or CI fix lands without a human on the card.

The panel agrees within 1.25 points, and hides one real objection. El Crítico takes the model layer apart: any provider means a choice of hosted APIs, not a choice of where inference runs. La Jefa adds the second cost, that without an unattended mode nothing reaches her pipelines.

El Crítico wins on framing and loses on consequence: hosted-only inference is a constraint, not a dealbreaker, for a team already sending code to a provider. La Jefa is overruled: a framework with no unattended mode was never bidding for her pipeline. Adopt with conditions, the condition being that inference leaves your network and you have said so in writing.

El Hacker and La Jefa agree this is a manager rather than an agent. He values a licence that keeps the fork alive; she wants a console and finds an inventory instead. El Crítico ignores both and points at what the manager does to other vendors' installs.

El Crítico wins the practical question: a tool that installs and removes somebody else's binaries owns a failure mode neither of the others priced. La Jefa's inventory is a real gain and does not offset it. Adopt with conditions, the condition being that you keep installing and updating the agent CLIs the way you always did, and let this only drive them.

Two points from El Hacker's 8.25 to El Crítico's 6.25, which for this board is consensus. El Hacker likes that ModelFactory swaps vendors in two lines. El Crítico supplies the caveat: interpreters execute Python and shell commands on the host, in a framework built for loops that run unattended for thousands of turns.

El Crítico wins on the default and loses on the conclusion: an unattended loop with a shell is a reason to put a container around it, not a reason to refuse the framework. El Hacker is overruled on running it as shipped. Adopt with conditions, the condition being the interpreters confined before the first thousand- turn run.

El Profesor's objection is narrow and correct: a score published by the vendor, on a test the vendor named, for a model the vendor built, is a marketing artefact until somebody reproduces it. La Inversora does not dispute it and does not care: her question is whether owning models creates a moat, and it does.

She wins on the company and he wins on the claim: believe the ownership story, discount the number. El Profesor is overruled only where he implies the product is therefore weak. El Crítico's split safety model is the condition. Trial only: run it in remote environments, measure it on your own repository, ignore the percentage.

El Hacker holds the top of a two-and-a-half point spread, unusual on a product with a hosted tier: he ran it under Apple Virtualization with no account and nothing reporting anywhere. El Profesor holds the reservation: Cua-Bench wraps three third-party suites and the record shows no number from any.

El Hacker wins on the framework and El Profesor is overruled on the purchase, since a missing benchmark is a reason to measure your own workload, not to decline the runtime. La Jefa keeps the cloud honest: an agent that stalls does not error, it accrues. Adopt with conditions, one backend pinned per workload, with timeouts and a hard budget cap.

The panel agrees from 5.75 to 6.75, the flattest result here, and flat agreement is the least useful kind. What it hides is El Crítico's objection, which moved nobody's score: the star count reads like a mature product and the release history does not.

El Amigo's case, the official harness for a model you already pay for, is postponed rather than overruled. El Profesor wins: the docs site fetched as a bare title, the tool catalog returned nothing, and BENCHMARK.md carries no numbers. The design is principled, the evidence pending. Trial only, pinned to a commit with your skills in your own repository, exiting when a stable release exists.

El Profesor and El Crítico both stop at a boundary the marketing does not draw. He notes that the cache figure is self-reported with no method attached; El Crítico notes that the symbol resolution everyone will quote is exact for one language only. La Jefa, unusually, is the enthusiast here.

Both caveats are real and neither is a defect, because the row states them itself. El Crítico is overruled on severity: a tool that is exact for Go and ordinary elsewhere is still exact for Go. Adopt, if you write Go, and confirm the cache economics on your own sessions before you count on them.

El Amigo scores usefulness high because the interface tells you where you are the bottleneck, which is the thing that actually slows a person running several features. El Crítico scores reliability lower because the tool watches the last mile without owning it: it reports the state of a pull request that something else was supposed to open.

El Crítico is right and El Amigo still wins, because a reporting gap you can see is cheaper than a queue you cannot. He is overruled on severity. Adopt with conditions: check each feature reaches a pull request yourself before you start the next three.

El Hacker likes the filesystem conventions and El Profesor likes that behaviour can be read off a directory tree. El Crítico reads the same row differently and notices what is absent: no command execution, no browser, no multi-file editing, no tool protocol.

He wins on the question of what this is, and both are overruled on the question of what it is for, because a well-organised agent that cannot touch a repository is not a coding tool. La Inversora's reading, that model selection routes through the parent's own service, explains the shape. Trial only, and only for an internal assistant rather than anything that writes code.

El Crítico and La Jefa disagree about the same dependency. He calls a pipeline welded to one vendor's CLI a single point of failure; she calls a budget the tool enforces itself the first spend control anybody has offered her. El Hacker adds that the licence is not what the badge says.

La Jefa wins for anyone already inside that vendor's world, and El Crítico is overruled on relevance: a dependency you already have is not a risk you are taking. El Hacker's point stands. Adopt, if that CLI is already the one you run; if it is not, none of this is portable.

The split is two points and it is about the maintainer, not the code. El Hacker scores it highest because every abstraction is a Go interface and Ollama is a first-class provider. La Inversora scores lowest and prices the reason, a services business wearing a framework. El Crítico names the same thing as breadth per maintainer.

Neither objection is a reason to refuse. El Profesor wins: capability derived from the registry rather than declared is the design that outlives a maintainer's calendar, and La Inversora is overruled on adoption. Adopt with conditions, Go services only, as La Jefa requires, and deployed through your own pipeline.

El Amigo and El Crítico are describing the same container from inside and outside. He values an agent that never interrupts to ask permission, because the boundary already answers the question; El Crítico points out that the agent writes the file defining that boundary. La Jefa wants Docker on sixty desks.

El Crítico's objection is the sharpest on the panel and it is not disqualifying, because a container the agent extends is still a container, and the alternative is a prompt nobody reads. He is overruled on severity. Adopt, provided the Dockerfiles it writes are reviewed like any other file it produces.

El Hacker praises the tool's open-source, local-first design, which gives the user total control. El Crítico and La Jefa correctly identify what this control costs: features. As El Crítico notes, there is no git integration, a significant omission for a coding tool. La Jefa points out the lack of enterprise controls, making it unsuitable for team deployment. The disagreement is about who the tool is for: the individual experimenter or the professional team.

For the individual developer who wants a free, flexible testbed for multiple agents, El Hacker's reading is correct. The missing features are acceptable trade-offs for total ownership. For any team workflow, El Crítico and La Jefa are right; the risks are too high. The lack of version control is a dealbreaker for any serious coding task. Adopt for personal exploration, but do not use it on production code.

La Jefa scores cost at the ceiling because it is free and already installed on machines she administers. El Hacker scores usefulness at 2 because there is nothing to configure and nothing to own. El Crítico settles what they are both circling: the vendor's own documentation directs you elsewhere for agentic work, so this is not competing with the rest of the board.

La Jefa wins, because a free feature already present on sixty desks needs no adoption decision at all. El Hacker is overruled on relevance: he was measuring a tool that never claimed to be one. Adopt with conditions, the condition being that nobody mistakes it for an agent.

El Profesor scores it highest on the panel because writing one snippet instead of ten tool calls is a real reduction in round trips, and he can show the arithmetic. El Crítico agrees with the arithmetic and asks what the code runs inside, which the project answers less precisely than it answers everything else.

El Profesor wins on the design and El Crítico wins on the deployment, which means the ruling depends on what the process can reach rather than on the library. La Jefa's containment instinct is the right one here. Adopt with conditions, the condition being that you expose only modules you would let a stranger call.

El Profesor's point is method: the benchmark machinery is in the repository, so any claim about which small model works can be reproduced by the reader rather than believed. El Crítico's point is what that machinery surrounds: repairs and caps that exist because the target models are weak.

They are describing the same design from two ends and El Crítico is overruled on framing, not on fact: compensating for a weak model is the entire purpose, and it is stated openly. El Hacker's endpoints make it worth the trouble. Adopt with conditions: run the included harness on your own hardware before trusting any model profile it ships.

Agreement, and from the least sentimental direction. La Jefa gets one framework for the .NET team and the Python team, from a vendor "we already have agreements with". El Profesor gets replay from a stored checkpoint, which he notes very few of these frameworks provide. Nobody found a dealbreaker.

The two complaints are real and small. El Crítico wants parity checked before a language is chosen, since Go sits in its own repository. El Hacker cannot bring his tool ecosystem and is overruled: this was built for somebody with a cloud account, and that is the buyer. Adopt, deciding where agents are hosted before the default decides.

El Hacker scores this high because the licence is permissive, the endpoint is mine and the protocol client is real. El Crítico takes the same multi-runtime design and says that whatever the workspace can offer across five different backends is bounded by the weakest of them, and nothing documented reconciles their differences. La Inversora is reading the gateway economics.

El Hacker wins for anyone who will pick one runtime and stay there, and El Crítico is right for anyone who will not. Adopt with conditions, the condition being that you choose your runtime once and stop treating the others as a feature.

El Hacker calls off the grudge entirely: nine API shapes, Ollama and vLLM with the key left blank, extensions as ordinary TypeScript. La Inversora is "long the code, flat the company", since distribution runs through other vendors' subscriptions. El Crítico names the reach: a browser tool stealthed by default that attaches to Slack.

La Inversora is overruled on the score: platform risk to Stencil Labs is not platform risk to you while the licence is MIT. El Crítico sets the terms instead, and El Profesor's numbers are self-reported but reproducible, which is rare here. Adopt with conditions, the conditions being an account with nothing to leak and /collab left unused.

The spread is a point and a half, the narrowest here, and no critic reaches seven. El Crítico cannot audit what the recorder keeps; El Profesor cannot find the indexing method behind time, topic, person and tool. El Hacker calls closed source the ceiling on every score he gives it.

La Inversora is right that the accumulated history is a real moat, which is a reason for care rather than for purchase: the switching cost lands before the recall figure is published. She is overruled on timing. Trial only, twelve people as La Jefa proposes, and the exit criterion is a written statement of what the recorder excludes.

El Profesor rates the architecture at the top of this panel because a workflow that can be replayed step by step is debuggable in a way agent systems almost never are. La Inversora rates durability at 5 because a permissive licence from a small lab is not a supplier. La Jefa, unusually, sides with El Profesor: the governance features she normally begs for are already here.

El Profesor and La Jefa carry it, and La Inversora is overruled on adoption while being upheld on planning: you own this the moment you deploy it. El Crítico's isolation limit is the condition. Adopt with conditions: keep anything needing real host access outside the sandbox and say so.

El Hacker cannot bring a key, a model or a fork, and scores accordingly. La Jefa reads that same constraint as a decision already made on her behalf, which removes sixty conversations she would otherwise have to have. El Crítico raises the objection that is neither of theirs, about what an administrator can push into a session.

La Jefa wins on an estate and El Hacker is overruled there, since a fleet is not a workstation and the freedom he wants is the variance she is paid to remove. El Crítico's warning survives both. Adopt with conditions, the condition being that the hook scripts are reviewed like production code.

El Hacker is two points above La Jefa and they are pricing the same deployment. He calls the ee/ directory open core wearing an open-source badge and forgives it for the OpenAPI surface. La Jefa counts the part that is not in the licence: graphics hardware sized for sixty, a capacity plan nobody has done, and a person paged on Monday.

La Jefa wins, because free software with an operator is not free, and El Hacker is overruled on cost only. El Crítico's category warning is upheld: judge it as completion, not as an agent. Adopt with conditions: a named owner, a capacity plan and hardware budgeted before rollout.

La Jefa is the only one above six and she is answering a question the others are not asked. She has the whole questionnaire on one page: air-gapped deployment, SSO, zero retention, IP indemnification. El Crítico is at 5.25 because you cannot try it: no free plan, annual terms, so the first real run happens after the signature.

La Jefa wins for the regulated buyer and El Crítico is overruled on adoption, not on the remedy, which is his own: a paid pilot with an exit clause. El Amigo is upheld: nobody else should sign. Adopt with conditions: a paid pilot, and La Inversora's change-of-control and data-migration terms after Tricentis.

El Profesor scores this well because the workspace exposes itself to its own agent through the same surface a person uses, which is a genuinely economical design. El Crítico agrees it is elegant and asks the question the design does not answer: a lead agent that can create worktrees and launch further sessions has no documented ceiling on how many.

El Crítico wins on the operational risk and El Profesor keeps the architecture; he is overruled on consequences, not on structure. Adopt with conditions, the condition being a hard cap on concurrent sessions that you set yourself before the lead agent runs.

El Amigo values the thing the design is for: several agents referencing one set of conversations, files and outputs, with nobody copying context between them. El Crítico values what it removes: the moment a person reads one agent's output before it becomes another's input. Same mechanism, opposite emphasis.

El Crítico wins on risk and El Amigo wins on ambition, and neither is overruled, because a product this young has not yet demonstrated which reading holds. La Jefa's platform gap decides the corporate case against it. Trial only: the free local edition, one team, and approvals reviewed by a human every time until you have seen it be wrong.

El Crítico and El Profesor are looking at opposite ends of the same small binary. He finds a capability listed in the documentation index that the README never explains; El Profesor finds the concurrency design to be the most careful thing on the row. Neither observation touches the other.

El Profesor wins on the part you will use every day and El Crítico wins on the part nobody has described, which makes the ruling easy: the undocumented thing is the one to leave alone. Adopt with conditions, the condition being that you do not enable anything the README does not explain.

El Crítico and El Profesor have found the same hole from two sides. He points at a jail that blocks obvious escapes and a README that recommends Docker for real isolation; El Profesor points at subagents sharing one working directory with nothing separating them. Neither is describing a flaw the other missed.

They win together and La Jefa's pipeline reading is the way to use them: the risks they describe are containable when the machine is disposable and severe when it is a developer's laptop. Adopt with conditions, the condition being a container around it, exactly as the README suggests.

El Hacker scores it high because the licence is permissive, the protocol works in both directions and the model routing reaches his own hardware. El Crítico scores reliability at 5 because a system designed to spread one request across thousands of calls has no documented ceiling on how far it spreads. El Profesor adds that the harness abstraction hides real behavioural differences.

El Crítico wins on the operational question and does not defeat the adoption, because the ceiling he wants is a configuration decision the operator can make. El Hacker carries the rest. Adopt with conditions: a fan-out limit and a spend alarm before the first production request.