The agenticengine
This is not
a coding assistant.
Codeflare runs governed engineering agents inside your own estate. Each change is backed by a spec, proven by tests, documented, and handed to your team to approve, whether that is a pull request to merge or a change to run.
Inference Mesh
Codeflare works with any inference provider. Inference Mesh is one more it can pull from. It turns the idle machines you already own into private, low-cost capacity for your agents. Long-running sessions stay warm, sensitive work never leaves your boundary, and every hosted provider stays first-class, as your default or your fallback.
Execution
Where the work gets done.
Codeflare is a customer-operated execution platform where engineers and AI agents design and architect systems, build and debug software, operate, patch, and migrate approved infrastructure, automate end-to-end tests, deploy, verify, and recover live systems together. Work happens inside authenticated, disposable browser sessions, with organizational rules, evidence, and human approval built into the workflow instead of bolted onto laptops or long-lived shared runners.
- t.anderson@metacortex.ai $ Clone codeflare-inference-mesh from production and switch to develop.
- clone complete · develop checked out · graph current HEAD matches origin/develop · worktree clean
- Enter planning mode for Inference Mesh routing.
- planning mode · 6 tasks · SDD requirements linked · TDD principles enforced
- Execute the plan. Stop if the approved scope changes.
- implementation complete · TDD suite green · worktree ready 6/6 tasks complete · requirement anchors updated
- Trigger review agents.
- code-reviewer: fallback assertion missing · doc-updater: clean · spec-reviewer: clean
- Fix it and rerun review. Show me the final diff when review is clean.
- code-reviewer: clean · doc-updater: clean · spec-reviewer: clean
- Push the reviewed head and open a PR to main.
- PR #1 opened · required checks green · ready to merge https://github.com/nikolanovoselec/codeflare-inference-mesh/pull/1
- Deploy develop to integration.
- integration deploy green · dynamic/codeflare-mesh route live · private node path ready
- Run the end-to-end inference path on integration.
- AI Gateway → Inference Router → cf1:network Mesh → Zero Trust Client → private node stream complete · reservation released · audit event recorded
- Approve, update the PR body, and squash-merge to main. Keep the implementation and verification details in the PR body.
- PR #1 squash-merged · main updated · PR closed main @ 8ef188a · production deploy queued
- Reset develop to origin/main and force-push.
- develop aligned with origin/main · worktree clean origin/develop updated with --force-with-lease · 8ef188a
- t.anderson@metacortex.ai $ Trace CVE-2024-6387 across every internet-facing Linux host. Discovery only.
- CMDB: 2,418 hosts scanned · 186 publicly exposed · 37 running affected OpenSSH versions
- SSH to all 37 candidates in parallel. Confirm package version, glibc, and live sshd exposure.
- 37 checked in 42s · 31 confirmed vulnerable · 6 false positives removed
- Enter planning mode. Build a canary-first rollout for the 31 vulnerable hosts, with rollback and stop conditions.
- Ubuntu 18 · Debian 8 · RHEL 5 · 3 canaries · 7 rollout batches
- Show the rollback path and automatic stop conditions.
- rollback role rendered · serial: 5 · max_fail_percentage: 0 SSH reconnect and sshd health required after every host
- List every host in the canary batch.
- ansible-playbook openssh-cve-2024-6387.yml --limit cve-2024-6387-canary --list-hosts hosts (3): aws-fra-edge-03 · azure-fra-edge-02 · azure-zrh-bastion-01
- Show me the batch timeline before I approve.
- canary 45s · 6 rollout batches × 30s · final rescan 45s estimated 4m 30s · rolling sshd restart · no host reboot
- Execute the approved rollout. Stop before fleet batches unless all three canaries pass.
- canaries 3/3 patched · fixed OpenSSH packages verified SSH reconnect 3/3 · sshd healthy 3/3 · fleet gate open
- batch 1/7 passed · remaining six batches released automatically · 28 hosts remaining
- 7 batches completed in 3m 31s · 31/31 patched · failed 0 SSH reconnect 31/31 · sshd healthy 31/31
- 31 hosts healthy · rescanning all 2,418 CMDB assets for CVE-2024-6387 exposure
- 2,418 hosts rescanned · vulnerable hosts 0 · public exposure 0 31 fixed versions verified · rollback used 0
- Publish the discovery, rollout, and rescan evidence, then close SEC-4821.
- SEC-4821 closed · CMDB inventory, host evidence, package diffs, and rollout logs attached elapsed 4m 18s · 31 hosts remediated · remaining exposure 0
Velocity
The bottleneck was never typing speed.
The execution above is the operating model: one engineer sets intent while agents move through code, tests, deployment, and operations. The four proofs below show what keeps that speed controlled: egress, isolation, review, and spec.
Quality
Spec, tests, and docs, enforced as one.
Every run starts from requirements with acceptance criteria. At the pull request, Codeflare checks the diff against that contract and sends failures back to the agent until the code, its tests, and the docs all agree.
Approve the intent first
Before any code, a requirement and its acceptance criteria are written down. /sdd init bootstraps the repo into that spec-driven framework, backed by a knowledge graph of your code and decisions, so the agent builds against intent you already approved.
Enforcement is a loop
At every PR boundary, spec and TDD enforcers check the diff against its requirements and reject test theater. Findings route back to the agent, which fixes and re-verifies, and nothing merges until the build matches the spec.
Adoption
Legacy code, reverse-engineered into a spec-driven baseline.
Point /sdd init at an existing repo and it reverse-engineers the requirements, acceptance criteria, and knowledge graph an agent needs to work the code without drifting. /sdd clean brings a drifted spec back into line.
Operations
The same agents operate your infrastructure.
The governed harness is not only for code. On the same session model, under your own identity, agents patch servers, migrate workloads, provision clusters, and configure firewalls, proxies, and other appliances. They reach approved targets through your Zero Trust, never a broad VPN, and every action is proposed, approved, and evidenced.
Policy-scoped zero-trust tunnels
Internal hosts, databases, and control planes sit behind zero-trust access policy. A session gets only the routes its group is allowed, never the flat network. No broad VPN grant, and no credential living in the container.
Logged to your tenancy
Every connection and command flows through the same attributed path as model traffic, written to your logs in your tenancy: who reached what, when, and under which policy.
Security
Built on a Zero Trust foundation.
Every dangerous path is closed at the architecture level. A session authenticates through your IdP, runs in an isolated container in your tenancy, and reaches models only through your AI Gateway.
Context
The web, the way an agent reads it.
Heavy pages are mostly chrome an agent can't use. Codeflare loads each one in an isolated, ephemeral browser, runs the scripts, resolves the gate, and returns clean markdown, turning a 1.9 MB page into 12 kB worth reading.
context/automation
From reading pages to driving them.
Hand an agent a deployed flow and a mobile viewport, and the same isolated browser runs the end-to-end test: it navigates, taps, captures each screen, and judges the result against the acceptance criteria.
Control
Agents work inside your pipeline, not around it.
There is no shadow toolchain. Every agent change moves through your git, your CI, and your branch protections, then a panel of specialist reviewers, before a human approves the merge.
Observability
Watch every agent work in real time.
This is the operator's view of the same review: three reviewers on one diff at once, each showing what it's doing and spending as it goes. Follow any one closely, or send the run to the background and move on to the next task.
Cost
Every spend has a known actor.
Codeflare records cost where it is created: container time, browser work, tool calls, and model tokens. Each line rolls up to a user, team, agent, and route in your own estate.
Environment
Containers run in your tenancy, exist only while a session is active, and hibernate to zero when idle. The spend lands in your own estate as line items, not in a vendor black box.
Inference
Model traffic runs through your AI Gateway. Spend is visible by user, team, and group; each group is pinned to its approved models; and traffic fails over automatically when a provider degrades.
Agent tools
Because interception runs below the container, no CLI tool can slip past it. Every token an agent burns lands in the same attributed stream as the rest.
cost/tenancy
Deployed in your own estate.
Codeflare deploys into your own estate, with no vendor in the data path. Source, sessions, and model traffic stay inside your trust boundary, and a guided setup takes a fresh account to a running engine.
Platform
Your context, guidelines, and best practices, preloaded.
A session starts knowing your conventions, your codebase, and your past decisions, not as a blank slate. Skills load on demand and specialist reviewers stand ready, the same way for every supported agent.
platform/runs-everywhere
No client to install. Just a browser.
Codeflare runs in your own estate. The laptop or phone in front of an engineer is only a window onto the session, with no local toolchain to install, patch, or wipe.
Ready in seconds
A full Linux environment with every supported agent preinstalled boots in seconds. No golden images to maintain, no workstation build, no local toolchain to patch.
Access starts in your IdP
Add an engineer to the right group in your identity provider and they are productive on day one. Remove the membership and access is gone the same day, with no device to reclaim or wipe.
Check in from anywhere
Long-running sessions keep working whether you watch or not. Review findings, redirect an agent, or approve the next step from whatever device you have on you.
Continuity
The editor you already know
Visual Studio Code in your browser, running inside Codeflare: the editor you already know, turned into a bird's-eye view across the agent's execution at machine speed. Files change, checks run, the integrated terminal streams, and you stay oriented in a familiar workspace while the work moves faster than you could type it. Take the wheel and edit directly whenever you want.
- codeflare-inference-mesh
- packages
- node-agent
- proxy.go
- runtime.go
- scheduler.go
- router-worker
- README.md
- go.mod
- type ActiveCounter struct {
- value int64
- }
- func (c *ActiveCounter) Inc() {
- atomic.AddInt64(&c.value, 1)
- }
Tooling
Every tool call, attributed to a known identity.
An agent is only as safe as the tools it can reach. Codeflare routes every MCP server through one portal where each call runs as the signed-in user, scoped to least privilege and logged by name. Code mode folds the surface into one typed `code` tool in a sandbox.
Proof
Codeflare built this page.
The page you are reading is REQ-LANDING-001 in the Codeflare spec. It shipped through the same spec, test, and review gates described above, and every anchor below points at the real file.
In good company
FAQ
The answers, up front.
Where does our code and data live?
Inside your own estate. Workspace storage uses your object-storage buckets, metadata your key-value store, and sessions run in containers under your tenancy. Codeflare is software you operate, so we never hold your code. Storage is encrypted at rest, with customer-provided key options.
How do agents reach LLM providers?
Not directly. All model traffic is intercepted at the platform layer and routed through your AI Gateway with your keys, where guardrails and DLP apply. You pick approved models per group, set rate limits, and see attributed spend. Provider outages fail over automatically, and provider credentials never enter the container.
Do we have to use the Inference Mesh?
No. Codeflare works with any hosted inference provider as your default or your fallback, routed through your AI Gateway. The Inference Mesh is one optional additional source: it turns idle machines you already own into private, low-cost capacity, so long-running or sensitive work can stay inside your boundary. Run entirely on hosted providers, entirely on the mesh, or mix the two per group.
How does authentication work with our IdP?
Through zero-trust access in front of every surface, federating to Entra ID, Okta, Google Workspace, or any SAML/OIDC provider you already run. Provisioning is group membership; offboarding is group removal.
What stops an agent from escalating privileges?
Hard infrastructure boundaries. Each session runs in its own ephemeral container behind zero-trust access, with no peers to move to and no standing infrastructure to persist on. When the session ends, the container is destroyed.
Can agents operate infrastructure, not just write code?
Yes. The same governed session that builds also patches servers, migrates workloads, provisions clusters, and configures firewalls, proxies, and other appliances. It reaches approved targets through your Zero Trust, never a broad VPN, and every action is proposed, approved, and evidenced before it touches a host, with no standing credentials left behind.
Which agents are supported?
Claude Code, OpenAI Codex, GitHub Copilot, Pi, Google Antigravity, and OpenCode, selectable per session with the same isolation and governance regardless of choice.
What does it cost to run?
Pay-per-use on your own bill: container minutes while sessions run, storage per byte, and your negotiated model rates through the AI Gateway. No per-seat licenses, no idle fleet, and no vendor margin on your inference.
Does this replace our existing SDLC tooling?
It works through your existing tooling rather than replacing it. Agents commit through your git, run your CI, and obey your branch protections; the review pipeline layers extra gates on top and removes none of yours.
get-started
Deploy Codeflare in your environment.
New to engineering agents, scoping a pilot, or reviewing the security model? Tell us about your environment and we'll take it from there.
Your message goes directly to the team that builds Codeflare. Expect a reply within 1 to 2 business days. Submissions are protected against bots and are not stored. Your data is never sold or shared.